lean/OAI/Probability/LogConcave/OraclePrograms/Program.lean

import Mathlib
import OAI.Probability.LogConcave.Model

namespace OAI

section
section
noncomputable section
open MeasureTheory Filter
open scoped ENNReal NNReal Topology

namespace LogConcaveSampling.OracleCompiler

structure Program (Ω : Type*) [MeasurableSpace Ω] (d q : ℕ)
    (O : Type*) [MeasurableSpace O] where
  query : Fin q → Ω × Transcript d q → Point d
  query_measurable : ∀ i, Measurable (query i)
  output : Ω × Transcript d q → O
  output_measurable : Measurable output

namespace Program
variable {Ω O : Type*} [MeasurableSpace Ω] [MeasurableSpace O] {d q : ℕ}

def history (A : Program Ω d q O) (V : Point d → ℝ) (ω : Ω) : ℕ → Transcript d q
  | 0 => 0
  | n + 1 =>
      let h := A.history V ω n
      if hn : n < q then
        Function.update h ⟨n, hn⟩ (firstOrderReply V (A.query ⟨n, hn⟩ (ω, h)))
      else h

def run (A : Program Ω d q O) (V : Point d → ℝ) (ω : Ω) : O :=
  A.output (ω, A.history V ω q)

def algorithm (A : Program Ω d q (Point d)) : OracleAlgorithm Ω d q where
  query := A.query
  query_measurable := A.query_measurable
  output := A.output
  output_measurable := A.output_measurable

lemma algorithm_history (A : Program Ω d q (Point d)) (V : Point d → ℝ) (ω : Ω) (n : ℕ) :
    A.algorithm.history V ω n = A.history V ω n := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [OracleAlgorithm.history, history, ih]
    rfl

lemma algorithm_run (A : Program Ω d q (Point d)) (V : Point d → ℝ) (ω : Ω) :
    A.algorithm.run V ω = A.run V ω := by
  unfold OracleAlgorithm.run run
  rw [algorithm_history]
  rfl

lemma history_tail (A : Program Ω d q O) (V : Point d → ℝ) (ω : Ω)
    (n : ℕ) (i : Fin q) (hi : n ≤ i.val) : A.history V ω n i = 0 := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [history]
    split_ifs with hn
    · rw [Function.update_of_ne (by intro h; have H := congrArg Fin.val h; dsimp at H; omega)]
      exact ih (by omega)
    · exact ih (by omega)

lemma history_stable (A : Program Ω d q O) (V : Point d → ℝ) (ω : Ω)
    {m n : ℕ} (hmn : m ≤ n) (i : Fin q) (hi : i.val < m) :
    A.history V ω n i = A.history V ω m i := by
  induction n, hmn using Nat.le_induction with
  | base => rfl
  | succ n hmn ih =>
    simp only [history]
    split_ifs with hn
    · rw [Function.update_of_ne (by intro h; have H := congrArg Fin.val h; dsimp at H; omega)]
      exact ih
    · exact ih

def mask (n : ℕ) (h : Transcript d q) : Transcript d q :=
  fun i => if i.val < n then h i else 0

lemma prefix_zero (h : Transcript d q) : mask 0 h = 0 := by
  funext i
  simp [mask]

lemma prefix_full (h : Transcript d q) : mask q h = h := by
  funext i
  simp [mask, i.isLt]

lemma prefix_succ (n : ℕ) (hn : n < q) (h : Transcript d q) :
    mask (n+1) h = Function.update (mask n h) ⟨n,hn⟩ (h ⟨n,hn⟩) := by
  funext i
  by_cases hi : i = ⟨n,hn⟩
  · subst i
    simp [mask]
  · rw [Function.update_of_ne hi]
    simp only [mask]
    have hne : i.val ≠ n := by intro he; exact hi (Fin.ext he)
    have he : (i.val < n+1) ↔ (i.val < n) := by omega
    simp only [he]

lemma history_eq_prefix (A : Program Ω d q O) (V : Point d → ℝ) (ω : Ω)
    {n : ℕ} (hn : n ≤ q) : A.history V ω n = mask n (A.history V ω q) := by
  funext i
  simp only [mask]
  split_ifs with hi
  · exact (A.history_stable V ω hn i hi).symm
  · exact A.history_tail V ω n i (by omega)

lemma history_spec (A : Program Ω d q O) (V : Point d → ℝ) (ω : Ω) (i : Fin q) :
    A.history V ω q i =
      firstOrderReply V (A.query i (ω, mask i.val (A.history V ω q))) := by
  rw [A.history_stable V ω (m := i.val+1) (by omega) i (by omega)]
  rw [history, dite_eq_left i.isLt]
  simp only [Function.update_self]
  rw [A.history_eq_prefix V ω (by omega)]

lemma history_unique (A : Program Ω d q O) (V : Point d → ℝ) (ω : Ω)
    (h : Transcript d q)
    (hh : ∀ i, h i = firstOrderReply V (A.query i (ω, mask i.val h))) :
    A.history V ω q = h := by
  have hp : ∀ n ≤ q, A.history V ω n = mask n h := by
    intro n hn
    induction n with
    | zero => simp [history, prefix_zero]
    | succ n ih =>
      have hnq : n < q := by omega
      rw [history, dite_eq_left hnq, ih (by omega), prefix_succ n hnq h, hh ⟨n,hnq⟩]
  simpa only [prefix_full] using hp q le_rfl

lemma measurable_prefix (n : ℕ) : Measurable (mask (d:=d) (q:=q) n) := by
  apply Measurable.of_eval
  intro i
  dsimp [mask]
  split_ifs
  · exact measurable_pi_apply i
  · exact measurable_const

lemma measurable_history (A : Program Ω d q O) (V : Point d → ℝ)
    (hV : Measurable (firstOrderReply V)) (n : ℕ) :
    Measurable (A.history V · n) := by
  induction n with
  | zero => exact measurable_const
  | succ n ih =>
    simp only [history]
    split_ifs with hn
    · apply Measurable.of_eval
      intro i
      by_cases hi : i = ⟨n,hn⟩
      · subst i
        simp only [Function.update_self]
        exact hV.comp ((A.query_measurable _).comp (measurable_id.prodMk ih))
      · simp only [Function.update_of_ne hi]
        exact (measurable_pi_apply i).comp ih
    · exact ih

lemma measurable_run (A : Program Ω d q O) (V : Point d → ℝ)
    (hV : Measurable (firstOrderReply V)) : Measurable (A.run V) :=
  A.output_measurable.comp (measurable_id.prodMk (A.measurable_history V hV q))

end Program
end LogConcaveSampling.OracleCompiler

namespace LogConcaveSampling.OracleCompiler.Program
variable {Ω O R : Type*} [MeasurableSpace Ω] [MeasurableSpace O] [MeasurableSpace R]
  {d q r : ℕ}

def leftTrace (h : Transcript d (q+r)) : Transcript d q := fun i => h (Fin.castAdd r i)
def rightTrace (h : Transcript d (q+r)) : Transcript d r := fun i => h (Fin.natAdd q i)

lemma measurable_leftTrace : Measurable (leftTrace (d:=d) (q:=q) (r:=r)) := by
  exact Measurable.of_eval fun index => measurable_pi_apply (Fin.castAdd r index)
lemma measurable_rightTrace : Measurable (rightTrace (d:=d) (q:=q) (r:=r)) := by
  exact Measurable.of_eval fun index => measurable_pi_apply (Fin.natAdd q index)

@[simp] lemma leftTrace_append (h : Transcript d q) (k : Transcript d r) :
    leftTrace (Fin.append h k) = h := by
  funext i
  simp [leftTrace]
@[simp] lemma rightTrace_append (h : Transcript d q) (k : Transcript d r) :
    rightTrace (Fin.append h k) = k := by
  funext i
  simp [rightTrace]

lemma leftTrace_prefix_left (h : Transcript d q) (k : Transcript d r) (n : ℕ) :
    leftTrace (mask n (Fin.append h k)) = mask n h := by
  funext i
  simp [leftTrace, mask]

lemma leftTrace_prefix_right (h : Transcript d q) (k : Transcript d r) (n : ℕ) :
    leftTrace (mask (q+n) (Fin.append h k)) = h := by
  funext i
  have hi : i.val < q+n := by omega
  simp [leftTrace, mask, hi]

lemma rightTrace_prefix_right (h : Transcript d q) (k : Transcript d r) (n : ℕ) :
    rightTrace (mask (q+n) (Fin.append h k)) = mask n k := by
  funext i
  simp [rightTrace, mask]

def seq (A : Program Ω d q O) (B : Program (Ω × O) d r R) :
    Program Ω d (q+r) R where
  query i p := Fin.addCases
    (fun j => A.query j (p.1, leftTrace p.2))
    (fun j => B.query j ((p.1, A.output (p.1,leftTrace p.2)), rightTrace p.2)) i
  query_measurable i := by
    refine Fin.addCases (fun j => ?_) (fun j => ?_) i
    · simpa only [Fin.addCases_left, Function.comp_def] using (A.query_measurable j).comp
        (measurable_fst.prodMk (measurable_leftTrace.comp measurable_snd))
    · simpa only [Fin.addCases_right, Function.comp_def] using (B.query_measurable j).comp
        ((measurable_fst.prodMk (A.output_measurable.comp
          (measurable_fst.prodMk (measurable_leftTrace.comp measurable_snd)))).prodMk
          (measurable_rightTrace.comp measurable_snd))
  output p := B.output ((p.1,A.output (p.1,leftTrace p.2)), rightTrace p.2)
  output_measurable := B.output_measurable.comp
    ((measurable_fst.prodMk (A.output_measurable.comp
      (measurable_fst.prodMk (measurable_leftTrace.comp measurable_snd)))).prodMk
        (measurable_rightTrace.comp measurable_snd))

lemma seq_history (A : Program Ω d q O) (B : Program (Ω × O) d r R)
    (V : Point d → ℝ) (ω : Ω) :
    (A.seq B).history V ω (q+r) =
      Fin.append (A.history V ω q) (B.history V (ω,A.run V ω) r) := by
  apply history_unique
  intro i
  refine Fin.addCases (fun j => ?_) (fun j => ?_) i
  · simp only [Fin.append_left, seq, Fin.addCases_left, Fin.val_castAdd,
      leftTrace_prefix_left]
    exact A.history_spec V ω j
  · simp only [Fin.append_right, seq, Fin.addCases_right, Fin.val_natAdd,
      leftTrace_prefix_right, rightTrace_prefix_right]
    exact B.history_spec V (ω,A.run V ω) j

lemma seq_run (A : Program Ω d q O) (B : Program (Ω × O) d r R)
    (V : Point d → ℝ) (ω : Ω) :
    (A.seq B).run V ω = B.run V (ω,A.run V ω) := by
  unfold run
  rw [seq_history]
  simp only [seq, leftTrace_append, rightTrace_append]
  rfl

def map (A : Program Ω d q O) (f : Ω × O → R) (hf : Measurable f) : Program Ω d q R where
  query := A.query
  query_measurable := A.query_measurable
  output p := f (p.1,A.output p)
  output_measurable := hf.comp (measurable_fst.prodMk A.output_measurable)

lemma map_history (A : Program Ω d q O) (f : Ω × O → R) (hf : Measurable f)
    (V : Point d → ℝ) (ω : Ω) (n : ℕ) :
    (A.map f hf).history V ω n = A.history V ω n := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [history, ih]
    rfl

lemma map_run (A : Program Ω d q O) (f : Ω × O → R) (hf : Measurable f)
    (V : Point d → ℝ) (ω : Ω) : (A.map f hf).run V ω = f (ω,A.run V ω) := by
  unfold run
  rw [map_history]
  rfl

def seedMap {Ξ : Type*} [MeasurableSpace Ξ] (A : Program Ω d q O)
    (f : Ξ → Ω) (hf : Measurable f) : Program Ξ d q O where
  query i p := A.query i (f p.1, p.2)
  query_measurable i := (A.query_measurable i).comp
    ((hf.comp measurable_fst).prodMk measurable_snd)
  output p := A.output (f p.1,p.2)
  output_measurable := A.output_measurable.comp
    ((hf.comp measurable_fst).prodMk measurable_snd)

lemma seedMap_history {Ξ : Type*} [MeasurableSpace Ξ] (A : Program Ω d q O)
    (f : Ξ → Ω) (hf : Measurable f) (V : Point d → ℝ) (ω : Ξ) (n : ℕ) :
    (A.seedMap f hf).history V ω n = A.history V (f ω) n := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [history, ih]
    rfl

lemma seedMap_run {Ξ : Type*} [MeasurableSpace Ξ] (A : Program Ω d q O)
    (f : Ξ → Ω) (hf : Measurable f) (V : Point d → ℝ) (ω : Ξ) :
    (A.seedMap f hf).run V ω = A.run V (f ω) := by
  unfold run
  rw [seedMap_history]
  rfl

def pure (f : Ω → O) (hf : Measurable f) : Program Ω d 0 O where
  query i := Fin.elim0 i
  query_measurable i := Fin.elim0 i
  output p := f p.1
  output_measurable := hf.comp measurable_fst

@[simp] lemma pure_run (f : Ω → O) (hf : Measurable f) (V : Point d → ℝ) (ω : Ω) :
    (pure (d:=d) f hf).run V ω = f ω := rfl

def oneQuery (x : Ω → Point d) (hx : Measurable x)
    (f : Ω × Reply d → O) (hf : Measurable f) : Program Ω d 1 O where
  query _ p := x p.1
  query_measurable _ := hx.comp measurable_fst
  output p := f (p.1,p.2 0)
  output_measurable := hf.comp (measurable_fst.prodMk
    ((measurable_pi_apply 0).comp measurable_snd))

lemma oneQuery_run (x : Ω → Point d) (hx : Measurable x)
    (f : Ω × Reply d → O) (hf : Measurable f) (V : Point d → ℝ) (ω : Ω) :
    (oneQuery x hx f hf).run V ω = f (ω, firstOrderReply V (x ω)) := by
  simp [run, history, oneQuery]

end LogConcaveSampling.OracleCompiler.Program

namespace LogConcaveSampling.OracleCompiler.Program
variable {Ω O : Type*} [MeasurableSpace Ω] [MeasurableSpace O] {d q r : ℕ}

def castCap (h : q = r) (A : Program Ω d q O) : Program Ω d r O := h ▸ A

lemma castCap_run (h : q = r) (A : Program Ω d q O) (V : Point d → ℝ) (ω : Ω) :
    (A.castCap h).run V ω = A.run V ω := by subst r; rfl

def iterate (A : Program (Ω × O) d q O) (init : Ω → O) (hi : Measurable init) :
    (n : ℕ) → Program Ω d (n*q) O
  | 0 => (pure init hi).castCap (Nat.zero_mul q).symm
  | n+1 => ((iterate A init hi n).seq A).castCap (Nat.succ_mul n q).symm

lemma iterate_run (A : Program (Ω × O) d q O) (init : Ω → O) (hi : Measurable init)
    (V : Point d → ℝ) (ω : Ω) (n : ℕ) :
    (A.iterate init hi n).run V ω = (fun x => A.run V (ω,x))^[n] (init ω) := by
  induction n with
  | zero => simp only [iterate, castCap_run, pure_run, Function.iterate_zero_apply]
  | succ n ih =>
    rw [iterate, castCap_run, seq_run, ih]
    exact (Function.iterate_succ_apply' (fun x => A.run V (ω,x)) n (init ω)).symm

end LogConcaveSampling.OracleCompiler.Program

noncomputable section
open MeasureTheory ProbabilityTheory
open scoped BigOperators RealInnerProductSpace

namespace LogConcaveSampling.SeedCompiler

variable {ι E : Type*} [Fintype ι] [DecidableEq ι]
  [NormedAddCommGroup E] [InnerProductSpace ℝ E]

def slotSum (a : ι → ℝ) (g : ι → E) : E := ∑ i, a i • g i

def slotTransform (c : ℝ) (a : ι → ℝ) (g : ι → E) : ι → E :=
  fun i => g i - (c * a i) • slotSum a g

omit [DecidableEq ι] in
lemma slot_energy (c : ℝ) (a : ι → ℝ)
    (hc : c ^ 2 * (∑ i, a i ^ 2) - 2 * c + 1 = 0) (g : ι → E) :
    (∑ i, ‖slotTransform c a g i‖ ^ 2) + ‖slotSum a g‖ ^ 2 =
      ∑ i, ‖g i‖ ^ 2 := by
  let S := slotSum a g
  have hi : ∑ i, a i * inner ℝ (g i) S = ‖S‖ ^ 2 := by
    simp_rw [← real_inner_smul_left]
    rw [← sum_inner]
    exact real_inner_self_eq_norm_sq S
  have hsum : (∑ i, ‖slotTransform c a g i‖ ^ 2) =
      (∑ i, ‖g i‖ ^ 2) - (2 * c) * (∑ i, a i * inner ℝ (g i) S) +
        c ^ 2 * (∑ i, a i ^ 2) * ‖S‖ ^ 2 := by
    simp only [slotTransform, norm_sub_sq_real, norm_smul, Real.norm_eq_abs,
      mul_pow, sq_abs, real_inner_smul_right]
    dsimp only [S]
    simp only [Finset.sum_add_distrib, Finset.sum_sub_distrib]
    simp only [Finset.mul_sum, Finset.sum_mul]
    simp only [mul_assoc, mul_comm, mul_left_comm]
  rw [hsum, hi]
  change _ + ‖S‖ ^ 2 = _
  nlinarith [mul_eq_zero_of_left hc (‖S‖ ^ 2)]

def restored (c : ℝ) (a : ι → ℝ) : ((ι → E) × E) →L[ℝ] (ι → E) :=
  ContinuousLinearMap.pi fun i =>
    ((ContinuousLinearMap.proj i).comp (ContinuousLinearMap.fst ℝ (ι → E) E)) -
    (c * a i) • (∑ j, a j •
      ((ContinuousLinearMap.proj j).comp (ContinuousLinearMap.fst ℝ (ι → E) E))) -
    a i • ContinuousLinearMap.snd ℝ (ι → E) E

omit [DecidableEq ι] in
@[simp] lemma restored_apply (c : ℝ) (a : ι → ℝ) (g : ι → E) (z : E) (i : ι) :
    restored c a (g,z) i = slotTransform c a g i - a i • z := by
  simp [restored, slotTransform, slotSum]

lemma dual_restored_left (c : ℝ) (a : ι → ℝ) (L : StrongDual ℝ (ι → E)) (j : ι) :
    ((L.comp (restored c a)).comp (ContinuousLinearMap.inl ℝ (ι → E) E)).comp
        (ContinuousLinearMap.single ℝ (fun _ : ι => E) j) =
      L.comp (ContinuousLinearMap.single ℝ (fun _ : ι => E) j) -
        (c * a j) • ∑ i, a i • L.comp (ContinuousLinearMap.single ℝ (fun _ : ι => E) i) := by
  ext x
  simp only [ContinuousLinearMap.comp_apply, ContinuousLinearMap.inl_apply,
    ContinuousLinearMap.single_apply]
  have h : restored c a (Pi.single j x,0) =
      Pi.single j x - (c * a j) • ∑ i, a i • Pi.single i x := by
    ext k
    simp [slotTransform, slotSum, Pi.single_apply, smul_smul, mul_comm, mul_left_comm]
  rw [h, map_sub, map_smul, map_sum]
  simp

lemma dual_restored_right (c : ℝ) (a : ι → ℝ) (L : StrongDual ℝ (ι → E)) :
    (L.comp (restored c a)).comp (ContinuousLinearMap.inr ℝ (ι → E) E) =
      -(∑ i, a i • L.comp (ContinuousLinearMap.single ℝ (fun _ : ι => E) i)) := by
  ext x
  have h : restored c a (0,x) = -(∑ i, a i • Pi.single i x) := by
    ext k
    simp [slotTransform, slotSum, Pi.single_apply]
  simp only [ContinuousLinearMap.comp_apply, ContinuousLinearMap.inr_apply]
  rw [h, map_neg, map_sum]
  simp

variable [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]

theorem restored_gaussian (c : ℝ) (a : ι → ℝ)
    (hc : c ^ 2 * (∑ i, a i ^ 2) - 2 * c + 1 = 0) :
    ((Measure.pi (fun _ : ι => stdGaussian E)).prod (stdGaussian E)).map
      (restored c a) = Measure.pi (fun _ : ι => stdGaussian E) := by
  apply Measure.ext_of_charFunDual
  ext L
  rw [charFunDual_map, charFunDual_prod, charFunDual_pi, charFunDual_pi]
  simp_rw [dual_restored_left, dual_restored_right, charFunDual_stdGaussian,
    ← Complex.exp_sum, ← Complex.exp_add]
  congr 1
  let D := InnerProductSpace.toDual ℝ E
  let l := fun i => L.comp (ContinuousLinearMap.single ℝ (fun _ : ι => E) i)
  have he := slot_energy c a hc (fun i => D.symm (l i))
  simp only [slotTransform, slotSum, ← map_smul, ← map_sum, ← map_sub,
    LinearIsometryEquiv.norm_map] at he
  simp only [norm_neg]
  norm_cast
  dsimp only [l] at he
  simp only [← Finset.sum_div, Finset.sum_neg_distrib]
  linarith

def sqrtCoefficient (a : ι → ℝ) : ℝ := 1 / (1 + Real.sqrt (1 - ∑ i, a i ^ 2))

omit [DecidableEq ι] in
lemma sqrtCoefficient_equation (a : ι → ℝ) (ha : (∑ i, a i ^ 2) ≤ 1) :
    (sqrtCoefficient a) ^ 2 * (∑ i, a i ^ 2) - 2 * sqrtCoefficient a + 1 = 0 := by
  have hsq := Real.sq_sqrt (sub_nonneg.mpr ha)
  have hpos : 0 < 1 + Real.sqrt (1 - ∑ i, a i ^ 2) := by positivity
  unfold sqrtCoefficient
  field_simp
  nlinarith

theorem sqrt_restored_gaussian (a : ι → ℝ) (ha : (∑ i, a i ^ 2) ≤ 1) :
    ((Measure.pi (fun _ : ι => stdGaussian E)).prod (stdGaussian E)).map
      (restored (sqrtCoefficient a) a) = Measure.pi (fun _ : ι => stdGaussian E) :=
  restored_gaussian _ _ (sqrtCoefficient_equation a ha)

end LogConcaveSampling.SeedCompiler

namespace LogConcaveSampling.SeedCompiler
variable {ι E O : Type*} [Fintype ι] [DecidableEq ι]
  [NormedAddCommGroup E] [InnerProductSpace ℝ E]

def ShiftInvariant (r : ℝ) (v : ι → ℝ) (M : E → (ι → E) → O) : Prop :=
  ∀ x Δ g, M (x + r • Δ) (fun i => g i + v i • Δ) = M x g

omit [DecidableEq ι] in
lemma absorption_pathwise {r D : ℝ} (v : ι → ℝ)
    (M : E → (ι → E) → O) (hM : ShiftInvariant r v M)
    (x : E) (c : ℝ) (g : ι → E) (z : E) :
    M (x + (r / (2 * D)) • z)
        (slotTransform c (fun i => v i / (2 * D)) g) =
      M x (restored c (fun i => v i / (2 * D)) (g,z)) := by
  have h := hM x ((1 / (2 * D)) • z)
    (restored c (fun i => v i / (2 * D)) (g,z))
  have hx : r • ((1 / (2 * D)) • z) = (r / (2 * D)) • z := by
    rw [smul_smul]; congr 1; ring
  have hs : (fun i => restored c (fun i => v i / (2 * D)) (g,z) i +
      v i • ((1 / (2 * D)) • z)) = slotTransform c (fun i => v i / (2 * D)) g := by
    funext i
    simp only [restored_apply, smul_smul]
    have hc : v i * (1 / (2 * D)) = v i / (2 * D) := by ring
    rw [hc, sub_add_cancel]
  simpa only [hx, hs] using h

omit [DecidableEq ι] in
lemma normalized_shift_bound {D : ℝ} (hD : 0 < D) (v : ι → ℝ)
    (hv : (∑ i, v i ^ 2) ≤ D ^ 2) :
    (∑ i, (v i / (2 * D)) ^ 2) ≤ 1 / 4 := by
  simp only [div_pow, ← Finset.sum_div]
  apply (div_le_iff₀ (sq_pos_of_pos (mul_pos (by norm_num) hD))).mpr
  nlinarith

variable [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E]
  [MeasurableSpace O]

theorem absorption_law {r D : ℝ} (hD : 0 < D) (v : ι → ℝ)
    (hv : (∑ i, v i ^ 2) ≤ D ^ 2) (M : E → (ι → E) → O)
    (hshift : ShiftInvariant r v M) (x : E) (hm : Measurable (M x)) :
    let a := fun i => v i / (2 * D)
    ((Measure.pi (fun _ : ι => stdGaussian E)).prod (stdGaussian E)).map
      (fun p => M (x + (r / (2 * D)) • p.2) (slotTransform (sqrtCoefficient a) a p.1)) =
      (Measure.pi (fun _ : ι => stdGaussian E)).map (M x) := by
  dsimp only
  let a := fun i => v i / (2 * D)
  have ha : (∑ i, a i ^ 2) ≤ 1 := (normalized_shift_bound hD v hv).trans (by norm_num)
  have he : (fun p : (ι → E) × E =>
      M (x + (r / (2 * D)) • p.2) (slotTransform (sqrtCoefficient a) a p.1)) =
      (M x) ∘ restored (sqrtCoefficient a) a := by
    funext p
    exact absorption_pathwise v M hshift x _ p.1 p.2
  rw [he, ← Measure.map_map hm (by fun_prop), sqrt_restored_gaussian a ha]

theorem restored_with_anchors {A : Type*} [MeasurableSpace A]
    (μ : Measure A) [SFinite μ] (a : ι → ℝ) (ha : (∑ i, a i ^ 2) ≤ 1) :
    (μ.prod ((Measure.pi (fun _ : ι => stdGaussian E)).prod (stdGaussian E))).map
      (Prod.map id (restored (sqrtCoefficient a) a)) =
      μ.prod (Measure.pi (fun _ : ι => stdGaussian E)) := by
  rw [← Measure.map_prod_map μ _ measurable_id (by fun_prop), Measure.map_id,
    sqrt_restored_gaussian a ha]

theorem absorption_with_anchors {A : Type*} [MeasurableSpace A]
    (μ : Measure A) [SFinite μ] {r D : ℝ} (hD : 0 < D) (v : ι → ℝ)
    (hv : (∑ i, v i ^ 2) ≤ D ^ 2) (M : E → (ι → E) → O)
    (hshift : ShiftInvariant r v M) (hm : Measurable (Function.uncurry M))
    (x : A → E) (hx : Measurable x) :
    let a := fun i => v i / (2 * D)
    (μ.prod ((Measure.pi (fun _ : ι => stdGaussian E)).prod (stdGaussian E))).map
      (fun p => (p.1, M (x p.1 + (r / (2 * D)) • p.2.2)
        (slotTransform (sqrtCoefficient a) a p.2.1))) =
      (μ.prod (Measure.pi (fun _ : ι => stdGaussian E))).map
        (fun p => (p.1, M (x p.1) p.2)) := by
  dsimp only
  let a := fun i => v i / (2 * D)
  have ha : (∑ i, a i ^ 2) ≤ 1 := (normalized_shift_bound hD v hv).trans (by norm_num)
  have hf : Measurable (fun p : A × (ι → E) => (p.1, M (x p.1) p.2)) :=
    measurable_fst.prodMk (hm.comp ((hx.comp measurable_fst).prodMk measurable_snd))
  rw [← restored_with_anchors μ a ha, Measure.map_map hf (by fun_prop)]
  congr 1
  funext p
  congr 1
  exact absorption_pathwise v M hshift (x p.1) _ p.2.1 p.2.2

end LogConcaveSampling.SeedCompiler

namespace LogConcaveSampling.SeedCompiler
variable {ι E : Type*} [Fintype ι]
  [NormedAddCommGroup E] [InnerProductSpace ℝ E]

lemma slotSum_transform (c : ℝ) (a : ι → ℝ) (g : ι → E) :
    slotSum a (slotTransform c a g) = (1 - c * ∑ i, a i ^ 2) • slotSum a g := by
  simp only [slotSum, slotTransform, smul_sub, smul_smul, Finset.sum_sub_distrib,
    ← Finset.sum_smul, sub_smul, one_smul]
  congr 2
  simp only [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro i _
  ring

lemma slotTransform_comp (c t : ℝ) (a : ι → ℝ) (g : ι → E) :
    slotTransform t a (slotTransform c a g) =
      slotTransform (c + t - t * c * ∑ i, a i ^ 2) a g := by
  funext i
  simp only [slotTransform, slotSum_transform, smul_smul]
  rw [sub_sub, ← add_smul]
  congr 2
  ring

lemma slotTransform_square (a : ι → ℝ) (ha : (∑ i, a i ^ 2) ≤ 1) (g : ι → E) :
    slotTransform (sqrtCoefficient a) a (slotTransform (sqrtCoefficient a) a g) =
      fun i => g i - a i • slotSum a g := by
  rw [slotTransform_comp]
  have h : sqrtCoefficient a + sqrtCoefficient a -
      sqrtCoefficient a * sqrtCoefficient a * ∑ i, a i ^ 2 = 1 := by
    nlinarith [sqrtCoefficient_equation a ha]
  rw [h]
  funext i
  simp [slotTransform]

lemma slotSum_energy_bound (a : ι → ℝ) (g : ι → E) :
    ‖slotSum a g‖ ^ 2 ≤ (∑ i, a i ^ 2) * (∑ i, ‖g i‖ ^ 2) := by
  calc
    ‖slotSum a g‖ ^ 2 ≤ (∑ i, |a i| * ‖g i‖) ^ 2 := by
      apply sq_le_sq₀ (norm_nonneg _) (Finset.sum_nonneg fun i _ => by positivity) |>.mpr
      simpa [slotSum, norm_smul] using norm_sum_le Finset.univ (fun i => a i • g i)
    _ ≤ (∑ i, |a i| ^ 2) * (∑ i, ‖g i‖ ^ 2) :=
      Finset.sum_mul_sq_le_sq_mul_sq Finset.univ (fun i => |a i|) (fun i => ‖g i‖)
    _ = _ := by simp only [sq_abs]

lemma sqrtCoefficient_nonneg (a : ι → ℝ) : 0 ≤ sqrtCoefficient a := by
  unfold sqrtCoefficient
  positivity

lemma sqrtCoefficient_le_one (a : ι → ℝ) : sqrtCoefficient a ≤ 1 := by
  unfold sqrtCoefficient
  rw [div_le_iff₀ (by positivity : 0 < 1 + Real.sqrt (1 - ∑ i, a i ^ 2))]
  nlinarith [Real.sqrt_nonneg (1 - ∑ i, a i ^ 2)]

lemma slotTransform_positive (a : ι → ℝ) (ha : (∑ i, a i ^ 2) ≤ 1) (g : ι → E) :
    0 ≤ ∑ i, inner ℝ (g i) (slotTransform (sqrtCoefficient a) a g i) := by
  have hs : ∑ i, a i * inner ℝ (g i) (slotSum a g) = ‖slotSum a g‖ ^ 2 := by
    simp_rw [← real_inner_smul_left]
    rw [← sum_inner]
    exact real_inner_self_eq_norm_sq _
  have hb := slotSum_energy_bound a g
  have hc := sqrtCoefficient_nonneg a
  have hc' := sqrtCoefficient_le_one a
  have hA : 0 ≤ ∑ i, a i ^ 2 := Finset.sum_nonneg fun i _ => sq_nonneg _
  have hG : 0 ≤ ∑ i, ‖g i‖ ^ 2 := Finset.sum_nonneg fun i _ => sq_nonneg _
  have hAG : (∑ i, a i ^ 2) * (∑ i, ‖g i‖ ^ 2) ≤ ∑ i, ‖g i‖ ^ 2 := by
    nlinarith
  simp only [slotTransform, inner_sub_right, real_inner_smul_right,
    real_inner_self_eq_norm_sq, Finset.sum_sub_distrib, mul_assoc, ← Finset.mul_sum]
  rw [hs]
  nlinarith [sq_nonneg ‖slotSum a g‖]

lemma sqrtCoefficient_eigenvalue (a : ι → ℝ) (ha : (∑ i, a i ^ 2) ≤ 1) :
    1 - sqrtCoefficient a * ∑ i, a i ^ 2 = Real.sqrt (1 - ∑ i, a i ^ 2) := by
  have hs := Real.sq_sqrt (sub_nonneg.mpr ha)
  have hp : 0 < 1 + Real.sqrt (1 - ∑ i, a i ^ 2) := by positivity
  unfold sqrtCoefficient
  field_simp
  nlinarith

def inverseCoefficient (a : ι → ℝ) : ℝ :=
  -sqrtCoefficient a / Real.sqrt (1 - ∑ i, a i ^ 2)

lemma inverseCoefficient_cancel (a : ι → ℝ) (ha : (∑ i, a i ^ 2) < 1) :
    sqrtCoefficient a + inverseCoefficient a -
      inverseCoefficient a * sqrtCoefficient a * ∑ i, a i ^ 2 = 0 := by
  have he := sqrtCoefficient_eigenvalue a ha.le
  have hp : 0 < Real.sqrt (1 - ∑ i, a i ^ 2) := Real.sqrt_pos.mpr (sub_pos.mpr ha)
  unfold inverseCoefficient
  field_simp
  rw [← he]
  ring

lemma inverse_slotTransform (a : ι → ℝ) (ha : (∑ i, a i ^ 2) < 1) (g : ι → E) :
    slotTransform (inverseCoefficient a) a (slotTransform (sqrtCoefficient a) a g) = g := by
  rw [slotTransform_comp, inverseCoefficient_cancel a ha]
  funext i
  simp [slotTransform]

lemma slotTransform_inverse (a : ι → ℝ) (ha : (∑ i, a i ^ 2) < 1) (g : ι → E) :
    slotTransform (sqrtCoefficient a) a (slotTransform (inverseCoefficient a) a g) = g := by
  rw [slotTransform_comp]
  have he := inverseCoefficient_cancel a ha
  have : inverseCoefficient a + sqrtCoefficient a -
      sqrtCoefficient a * inverseCoefficient a * ∑ i, a i ^ 2 = 0 := by nlinarith
  rw [this]
  funext i
  simp [slotTransform]

lemma inverse_slot_energy (a : ι → ℝ) (ha : (∑ i, a i ^ 2) ≤ 1 / 4) (g : ι → E) :
    (∑ i, ‖slotTransform (inverseCoefficient a) a g i‖ ^ 2) ≤
      4 * ∑ i, ‖g i‖ ^ 2 := by
  let h := slotTransform (inverseCoefficient a) a g
  have hA : (∑ i, a i ^ 2) < 1 := ha.trans_lt (by norm_num)
  have he := slot_energy (sqrtCoefficient a) a (sqrtCoefficient_equation a hA.le) h
  rw [slotTransform_inverse a hA g] at he
  have hb := slotSum_energy_bound a h
  have hs : 0 ≤ ∑ i, ‖h i‖ ^ 2 := Finset.sum_nonneg fun i _ => sq_nonneg _
  have hB : (∑ i, a i ^ 2) * (∑ i, ‖h i‖ ^ 2) ≤ (1 / 4) * (∑ i, ‖h i‖ ^ 2) :=
    mul_le_mul_of_nonneg_right ha hs
  change (∑ i, ‖h i‖ ^ 2) ≤ _
  nlinarith

end LogConcaveSampling.SeedCompiler

end
end
end
end

end OAI