import Mathlib
import OAI.Probability.LogConcave.OraclePrograms.Program

namespace OAI

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

noncomputable section
open MeasureTheory ProbabilityTheory
open scoped BigOperators RealInnerProductSpace

namespace LogConcaveSampling.SeedCompiler
open OracleCompiler
open OracleCompiler.Program

def terminalMean (d : ℕ) (r σ : ℝ) :
    Program (Point d × (Fin 2 → Point d)) d 1 (Point d) :=
  oneQuery (fun p => p.1 + r • p.2 0) (by fun_prop)
    (fun p => p.2.2 + σ • p.1.2 1) (by fun_prop)

def terminalSample (d : ℕ) (r η : ℝ) :
    Program (Point d × (Fin 3 → Point d)) d 1 (Point d) :=
  oneQuery (fun p => p.1 + r • p.2 0) (by fun_prop)
    (fun p => p.1.2 0 - r • p.2.2 + (Real.sqrt 3 * η / 2) • p.1.2 1 +
      (η / 2) • p.1.2 2) (by fun_prop)

lemma terminalMean_run {d : ℕ} (r σ : ℝ) (V : Point d → ℝ)
    (x : Point d) (g : Fin 2 → Point d) :
    (terminalMean d r σ).run V (x,g) = gradient V (x+r • g 0) + σ • g 1 := by
  rw [terminalMean, oneQuery_run]
  rfl

lemma terminalSample_run {d : ℕ} (r η : ℝ) (V : Point d → ℝ)
    (x : Point d) (g : Fin 3 → Point d) :
    (terminalSample d r η).run V (x,g) = g 0 - r • gradient V (x+r • g 0) +
      (Real.sqrt 3 * η / 2) • g 1 + (η / 2) • g 2 := by
  rw [terminalSample, oneQuery_run]
  rfl

def terminalShift (n : ℕ) : Fin (n+1) → ℝ := fun i => if i = 0 then -1 else 0

lemma terminalShift_energy (n : ℕ) : (∑ i, terminalShift n i ^ 2) = 1 := by
  simp [terminalShift]

lemma terminalQuery_invariant {d n : ℕ} (x Δ : Point d) (r : ℝ)
    (g : Fin (n+1) → Point d) :
    (x + r • Δ) + r • (g 0 + terminalShift n 0 • Δ) = x+r • g 0 := by
  simp only [terminalShift, ite_true, neg_smul, one_smul]
  module

lemma terminalMean_shift {d : ℕ} (r σ : ℝ) (V : Point d → ℝ) :
    ShiftInvariant r (terminalShift 1) (fun x g => (terminalMean d r σ).run V (x,g)) := by
  intro x Δ g
  simp only [terminalMean_run, terminalQuery_invariant]
  simp [terminalShift]

lemma terminalSample_shift {d : ℕ} (r η : ℝ) (V : Point d → ℝ)
    (x Δ : Point d) (g : Fin 3 → Point d) :
    (terminalSample d r η).run V (x+r • Δ, fun i => g i + terminalShift 2 i • Δ) =
      (terminalSample d r η).run V (x,g) - Δ := by
  simp only [terminalSample_run, terminalQuery_invariant]
  simp only [terminalShift, Fin.reduceEq, ite_true, ite_false,
    neg_smul, one_smul, zero_smul, add_zero]
  module

lemma terminalMean_history_shift {d : ℕ} (r σ : ℝ) (V : Point d → ℝ)
    (x Δ : Point d) (g : Fin 2 → Point d) :
    (terminalMean d r σ).history V (x+r • Δ,fun i => g i+terminalShift 1 i • Δ) 1 =
      (terminalMean d r σ).history V (x,g) 1 := by
  simp only [Program.history, terminalMean, oneQuery, Nat.lt_add_one, dite_eq_left,
    terminalQuery_invariant]

lemma terminalSample_history_shift {d : ℕ} (r η : ℝ) (V : Point d → ℝ)
    (x Δ : Point d) (g : Fin 3 → Point d) :
    (terminalSample d r η).history V (x+r • Δ,fun i => g i+terminalShift 2 i • Δ) 1 =
      (terminalSample d r η).history V (x,g) 1 := by
  simp only [Program.history, terminalSample, oneQuery, Nat.lt_add_one, dite_eq_left,
    terminalQuery_invariant]

end LogConcaveSampling.SeedCompiler

end
end

end

section

noncomputable section
namespace LogConcaveSampling.SeedCompiler
open MeasureTheory ProbabilityTheory Function
open scoped BigOperators

variable {Ω A ι E : Type*} [MeasurableSpace Ω] [MeasurableSpace A]
  [Fintype ι] [DecidableEq ι]
  [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E]
  [MeasurableSpace E] [BorelSpace E]

theorem restored_from_joint_law (κ : Measure Ω) [SFinite κ] (μ : Measure A) [SFinite μ]
    (anchor : Ω → A) (noise : Ω → E) (ha : Measurable anchor) (hz : Measurable noise)
    (hlaw : κ.map (fun w => (anchor w,noise w))=μ.prod (stdGaussian E))
    (a : ι → ℝ) (ha2 : (∑i,a i^2)≤1) :
    (κ.prod (Measure.pi fun _ : ι => stdGaussian E)).map
      (fun z => (anchor z.1,restored (sqrtCoefficient a) a (z.2,noise z.1)))=
        μ.prod (Measure.pi fun _ : ι => stdGaussian E) := by
  let γ : Measure (ι → E) := Measure.pi fun _ => stdGaussian E
  have hAZ : MeasurePreserving (fun w => (anchor w,noise w)) κ (μ.prod (stdGaussian E)) :=
    ⟨ha.prodMk hz,hlaw⟩
  have hp := hAZ.prod (MeasurePreserving.id γ)
  have hs := (MeasurePreserving.id μ).prod (Measure.measurePreserving_swap (μ:=stdGaussian E) (ν:=γ))
  have ht := hs.comp ((measurePreserving_prodAssoc μ (stdGaussian E) γ).comp hp)
  have hr : MeasurePreserving (Prod.map id (restored (sqrtCoefficient a) a))
      (μ.prod (γ.prod (stdGaussian E))) (μ.prod γ) :=
    ⟨by fun_prop,restored_with_anchors μ a ha2⟩
  exact (hr.comp ht).map_eq

theorem restored_error_integral (κ : Measure Ω) [SFinite κ] (μ : Measure A) [SFinite μ]
    (anchor : Ω → A) (noise : Ω → E) (ha : Measurable anchor) (hz : Measurable noise)
    (hlaw : κ.map (fun w => (anchor w,noise w))=μ.prod (stdGaussian E))
    (a : ι → ℝ) (ha2 : (∑i,a i^2)≤1) (f : A × (ι → E) → ℝ)
    (hf : Integrable f (μ.prod (Measure.pi fun _ : ι => stdGaussian E))) :
    Integrable (fun z : Ω × (ι → E) =>
      f (anchor z.1,restored (sqrtCoefficient a) a (z.2,noise z.1)))
      (κ.prod (Measure.pi fun _ : ι => stdGaussian E)) ∧
    (∫z : Ω × (ι → E),f (anchor z.1,restored (sqrtCoefficient a) a (z.2,noise z.1))
      ∂κ.prod (Measure.pi fun _ : ι => stdGaussian E))=
        ∫z,f z ∂μ.prod (Measure.pi fun _ : ι => stdGaussian E) := by
  let T : Ω × (ι → E) → A × (ι → E) := fun z =>
    (anchor z.1,restored (sqrtCoefficient a) a (z.2,noise z.1))
  have hm : Measurable T := (ha.comp measurable_fst).prodMk ((restored (sqrtCoefficient a) a).measurable.comp
    (measurable_snd.prodMk (hz.comp measurable_fst)))
  have he : (κ.prod (Measure.pi fun _ : ι => stdGaussian E)).map T=
      μ.prod (Measure.pi fun _ : ι => stdGaussian E) :=
    restored_from_joint_law κ μ anchor noise ha hz hlaw a ha2
  have hi : Integrable f ((κ.prod (Measure.pi fun _ : ι => stdGaussian E)).map T) := he ▸ hf
  exact ⟨hi.comp_measurable hm,(integral_map hm.aemeasurable hi.aestronglyMeasurable).symm.trans
    (by rw [he])⟩
end LogConcaveSampling.SeedCompiler

end

end

end

end OAI