lean/OAI/Probability/LogConcave/OraclePrograms/Expression.lean

import Mathlib
import OAI.Probability.LogConcave.OraclePrograms.TerminalMean
import OAI.Probability.LogConcave.Sampling.TerminalMean

namespace OAI

section
section
noncomputable section
open MeasureTheory

namespace LogConcaveSampling.OracleCompiler

inductive Expression (X : Type*) [MeasurableSpace X] (d : ℕ) where
  | noise (base : X → Point d) (measurable_base : Measurable base) (noise : ℝ)
  | add (a : ℝ) (center : Expression X d) (k q : ℕ)
      (child : Program (Point d × (Fin k → Point d)) d q (Point d))
      (P : (Fin k → Point d) → (Fin k → Point d)) (measurable_P : Measurable P)
      (rest : Expression X d)

namespace Expression
variable {X : Type*} [MeasurableSpace X] {d : ℕ}

@[reducible] def slots : Expression X d → ℕ
  | .noise .. => 1
  | .add _ C k _ _ _ _ T => C.slots + (k + T.slots)

@[reducible] def calls : Expression X d → ℕ
  | .noise .. => 0
  | .add _ C _ q _ _ _ T => C.calls + (q + T.calls)

def leftBlock {c k t : ℕ} (g : Fin (c+(k+t)) → Point d) : Fin c → Point d :=
  fun i => g (Fin.castAdd (k+t) i)
def middleBlock {c k t : ℕ} (g : Fin (c+(k+t)) → Point d) : Fin k → Point d :=
  fun i => g (Fin.natAdd c (Fin.castAdd t i))
def rightBlock {c k t : ℕ} (g : Fin (c+(k+t)) → Point d) : Fin t → Point d :=
  fun i => g (Fin.natAdd c (Fin.natAdd k i))

lemma measurable_leftBlock (c k t : ℕ) : Measurable (leftBlock (d:=d) (c:=c) (k:=k) (t:=t)) := by
  unfold leftBlock
  fun_prop
lemma measurable_middleBlock (c k t : ℕ) : Measurable (middleBlock (d:=d) (c:=c) (k:=k) (t:=t)) := by
  unfold middleBlock
  fun_prop
lemma measurable_rightBlock (c k t : ℕ) : Measurable (rightBlock (d:=d) (c:=c) (k:=k) (t:=t)) := by
  unfold rightBlock
  fun_prop

def compile : (C : Expression X d) →
    Program (X × (Fin C.slots → Point d)) d C.calls (Point d)
  | .noise b hb n => Program.pure (fun z => b z.1+n • z.2 0) (by fun_prop)
  | .add a C k q M P hP T => by
      let Ω := X × (Fin (C.slots+(k+T.slots)) → Point d)
      let A : Program Ω d C.calls (Point d) := C.compile.seedMap
        (fun z => (z.1,leftBlock z.2)) (by
          exact measurable_fst.prodMk ((measurable_leftBlock _ _ _).comp measurable_snd))
      let B : Program (Ω × Point d) d q (Point d) := M.seedMap
        (fun z => (z.2,P (middleBlock z.1.2))) (by
          exact measurable_snd.prodMk (hP.comp ((measurable_middleBlock _ _ _).comp
            (measurable_snd.comp measurable_fst))))
      let D : Program ((Ω × Point d) × Point d) d T.calls (Point d) :=
        (T.compile.seedMap (fun z => (z.1.1.1,rightBlock z.1.1.2)) (by
          exact (measurable_fst.comp (measurable_fst.comp measurable_fst)).prodMk
            ((measurable_rightBlock _ _ _).comp (measurable_snd.comp
              (measurable_fst.comp measurable_fst))))).map
          (fun z => a • z.1.2+z.2) (by fun_prop)
      exact A.seq (B.seq D)

def eval (V : Point d → ℝ) : (C : Expression X d) → X → (Fin C.slots → Point d) → Point d
  | .noise b _ n, x, g => b x+n • g 0
  | .add a C _ _ M P _ T, x, g =>
      a • M.run V (C.eval V x (leftBlock g),P (middleBlock g))+
        T.eval V x (rightBlock g)

theorem compile_run (C : Expression X d) (V : Point d → ℝ)
    (x : X) (g : Fin C.slots → Point d) : C.compile.run V (x,g)=C.eval V x g := by
  induction C with
  | noise b hb n => rfl
  | add a C k q M P hP T hC hT =>
    simp only [compile,Program.seq_run,Program.seedMap_run,Program.map_run,eval]
    rw [hC,hT]

theorem measurable_eval (C : Expression X d) (V : Point d → ℝ)
    (hV : Measurable (firstOrderReply V)) :
    Measurable (fun z : X × (Fin C.slots → Point d) => C.eval V z.1 z.2) := by
  have hr := C.compile.measurable_run V hV
  convert hr using 1
  funext z
  exact (compile_run C V z.1 z.2).symm

end Expression
end LogConcaveSampling.OracleCompiler

end

end

section

noncomputable section
namespace LogConcaveSampling.OracleCompiler.Program
open MeasureTheory

variable {Ω O R Ξ : Type*} [MeasurableSpace Ω] [MeasurableSpace O]
  [MeasurableSpace R] [MeasurableSpace Ξ] {d q r : ℕ}

structure Equivariant (A : Program Ω d q O) (f : Ω → Ω) (τ : O → O) : Prop where
  query : ∀i ω h,A.query i (f ω,h)=A.query i (ω,h)
  output : ∀ω h,A.output (f ω,h)=τ (A.output (ω,h))

namespace Equivariant
variable {A : Program Ω d q O} {f : Ω → Ω} {τ : O → O}

theorem history (hA : A.Equivariant f τ) (V : Point d → ℝ) (ω : Ω) (n : ℕ) :
    A.history V (f ω) n=A.history V ω n := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [Program.history,ih]
    split_ifs with hn
    · rw [hA.query]
    · rfl

theorem run (hA : A.Equivariant f τ) (V : Point d → ℝ) (ω : Ω) :
    A.run V (f ω)=τ (A.run V ω) := by
  unfold Program.run
  rw [hA.history,hA.output]

theorem executed_query (hA : A.Equivariant f τ) (V : Point d → ℝ) (ω : Ω)
    (i : Fin q) :
    A.query i (f ω,A.history V (f ω) i.val)=A.query i (ω,A.history V ω i.val) := by
  rw [hA.history,hA.query]

theorem seq (hA : A.Equivariant f τ) {B : Program (Ω × O) d r R} {σ : R → R}
    (hB : B.Equivariant (fun z => (f z.1,τ z.2)) σ) : (A.seq B).Equivariant f σ := by
  constructor
  · intro i ω h
    refine Fin.addCases (fun _ => ?_) (fun j => ?_) i
    · simp only [Program.seq,Fin.addCases_left]
      exact hA.query _ _ _
    · simp only [Program.seq,Fin.addCases_right,hA.output]
      exact hB.query j (ω,A.output (ω,leftTrace h)) (rightTrace h)
  · intro ω h
    simp only [Program.seq,hA.output]
    exact hB.output (ω,A.output (ω,leftTrace h)) (rightTrace h)

theorem seedMap (hA : A.Equivariant f τ) (g : Ξ → Ω) (hg : Measurable g)
    (f' : Ξ → Ξ) (hf : ∀ξ,g (f' ξ)=f (g ξ)) : (A.seedMap g hg).Equivariant f' τ := by
  constructor
  · intro i ξ h
    simpa only [Program.seedMap,hf] using hA.query i (g ξ) h
  · intro ξ h
    simpa only [Program.seedMap,hf] using hA.output (g ξ) h

theorem map (hA : A.Equivariant f τ) (g : Ω × O → R) (hg : Measurable g)
    (σ : R → R) (he : ∀ω x,g (f ω,τ x)=σ (g (ω,x))) :
    (A.map g hg).Equivariant f σ := by
  constructor
  · exact hA.query
  · intro ω h
    simp only [Program.map,hA.output,he]

end Equivariant

lemma pure_equivariant (g : Ω → O) (hg : Measurable g) (f : Ω → Ω) (τ : O → O)
    (he : ∀ω,g (f ω)=τ (g ω)) : (Program.pure (d:=d) g hg).Equivariant f τ := by
  constructor
  · intro i
    exact Fin.elim0 i
  · intro ω h
    exact he ω

lemma oneQuery_equivariant (x : Ω → Point d) (hx : Measurable x)
    (g : Ω × Reply d → O) (hg : Measurable g) (f : Ω → Ω) (τ : O → O)
    (he : ∀ω,x (f ω)=x ω) (hout : ∀ω a,g (f ω,a)=τ (g (ω,a))) :
    (Program.oneQuery x hx g hg).Equivariant f τ := by
  constructor
  · intro i ω h
    exact he ω
  · intro ω h
    exact hout ω (h 0)

end LogConcaveSampling.OracleCompiler.Program

end

end

section

noncomputable section
namespace LogConcaveSampling.OracleCompiler.Expression
open MeasureTheory

variable {X : Type*} [MeasurableSpace X] {d : ℕ}

def shiftSlots {n : ℕ} (v : Fin n → ℝ) (Δ : Point d) (g : Fin n → Point d) : Fin n → Point d :=
  fun i => g i+v i • Δ

def moveSeed {n : ℕ} (f : X → X) (v : Fin n → ℝ) (Δ : Point d)
    (z : X × (Fin n → Point d)) : X × (Fin n → Point d) := (f z.1,shiftSlots v Δ z.2)

lemma leftBlock_shift {c k t : ℕ} (u : Fin c → ℝ) (v : Fin k → ℝ) (w : Fin t → ℝ)
    (Δ : Point d) (g : Fin (c+(k+t)) → Point d) :
    leftBlock (shiftSlots (Fin.append u (Fin.append v w)) Δ g)=shiftSlots u Δ (leftBlock g) := by
  ext i
  simp [leftBlock,shiftSlots]
lemma middleBlock_shift {c k t : ℕ} (u : Fin c → ℝ) (v : Fin k → ℝ) (w : Fin t → ℝ)
    (Δ : Point d) (g : Fin (c+(k+t)) → Point d) :
    middleBlock (shiftSlots (Fin.append u (Fin.append v w)) Δ g)=shiftSlots v Δ (middleBlock g) := by
  ext i
  simp [middleBlock,shiftSlots]
lemma rightBlock_shift {c k t : ℕ} (u : Fin c → ℝ) (v : Fin k → ℝ) (w : Fin t → ℝ)
    (Δ : Point d) (g : Fin (c+(k+t)) → Point d) :
    rightBlock (shiftSlots (Fin.append u (Fin.append v w)) Δ g)=shiftSlots w Δ (rightBlock g) := by
  ext i
  simp [rightBlock,shiftSlots]

lemma noise_equivariant (b : X → Point d) (hb : Measurable b) (n c : ℝ)
    (f : X → X) (Δ : Point d) (he : ∀x,b (f x)=b x+c • Δ) :
    (noise b hb n).compile.Equivariant (moveSeed f (fun _ => 0) Δ) (fun y => y+c • Δ) := by
  apply Program.pure_equivariant
  intro z
  simp [moveSeed,shiftSlots,he]
  abel

lemma add_equivariant (a : ℝ) (C T : Expression X d) {k q : ℕ}
    (M : Program (Point d × (Fin k → Point d)) d q (Point d))
    (P : (Fin k → Point d) → (Fin k → Point d)) (hP : Measurable P)
    (f : X → X) (Δ : Point d) (u : Fin C.slots → ℝ) (v : Fin k → ℝ)
    (w : Fin T.slots → ℝ) (c t : ℝ)
    (hC : C.compile.Equivariant (moveSeed f u Δ) (fun y => y+c • Δ))
    (hM : (M.seedMap (fun z : Point d × (Fin k → Point d) => (z.1,P z.2))
      (measurable_fst.prodMk (hP.comp measurable_snd))).Equivariant
        (moveSeed (fun y => y+c • Δ) v Δ) id)
    (hT : T.compile.Equivariant (moveSeed f w Δ) (fun y => y+t • Δ)) :
    (add a C k q M P hP T).compile.Equivariant
      (moveSeed f (Fin.append u (Fin.append v w)) Δ) (fun y => y+t • Δ) := by
  let Ω := X × (Fin (C.slots+(k+T.slots)) → Point d)
  let F : Ω → Ω := moveSeed f (Fin.append u (Fin.append v w)) Δ
  let A : Program Ω d C.calls (Point d) := C.compile.seedMap
    (fun z => (z.1,leftBlock z.2))
    (measurable_fst.prodMk ((measurable_leftBlock _ _ _).comp measurable_snd))
  have hA : A.Equivariant F (fun y => y+c • Δ) := by
    apply hC.seedMap
    intro z
    simp only [F,moveSeed,leftBlock_shift]
  let B : Program (Ω × Point d) d q (Point d) := M.seedMap
    (fun z => (z.2,P (middleBlock z.1.2)))
    (measurable_snd.prodMk (hP.comp ((measurable_middleBlock _ _ _).comp
      (measurable_snd.comp measurable_fst))))
  let G : (Ω × Point d) → (Ω × Point d) := fun z => (F z.1,z.2+c • Δ)
  have hB : B.Equivariant G id := by
    constructor
    · intro i z h
      have H := hM.query i (z.2,middleBlock z.1.2) h
      simpa only [B,Program.seedMap,G,F,moveSeed,middleBlock_shift] using H
    · intro z h
      have H := hM.output (z.2,middleBlock z.1.2) h
      simpa only [B,Program.seedMap,G,F,moveSeed,middleBlock_shift] using H
  let D : Program ((Ω × Point d) × Point d) d T.calls (Point d) :=
    (T.compile.seedMap (fun z => (z.1.1.1,rightBlock z.1.1.2))
      ((measurable_fst.comp (measurable_fst.comp measurable_fst)).prodMk
        ((measurable_rightBlock _ _ _).comp (measurable_snd.comp
          (measurable_fst.comp measurable_fst))))).map
      (fun z => a • z.1.2+z.2) (by fun_prop)
  have hD : D.Equivariant (fun z => (G z.1,id z.2)) (fun y => y+t • Δ) := by
    apply Program.Equivariant.map
    · apply hT.seedMap
      intro z
      simp only [G,F,moveSeed,rightBlock_shift]
    · intro z y
      dsimp
      abel
  exact hA.seq (hB.seq hD)

end LogConcaveSampling.OracleCompiler.Expression

end

end

section

noncomputable section
namespace LogConcaveSampling.OracleCompiler.Expression
open MeasureTheory
open scoped NNReal

variable {X : Type*} [PseudoMetricSpace X] [MeasurableSpace X] {d : ℕ}

def FixedSeedLip (C : Expression X d) (V : Point d → ℝ) (K : ℝ≥0) : Prop :=
  ∀g,LipschitzWith K (fun x => C.eval V x g)

lemma noise_fixedSeed_lip (b : X → Point d) (hb : Measurable b) (n : ℝ)
    (V : Point d → ℝ) {K : ℝ≥0} (h : LipschitzWith K b) :
    FixedSeedLip (noise b hb n) V K := by
  intro g
  apply LipschitzWith.of_dist_le_mul
  intro x y
  simpa only [eval,dist_add_right] using h.dist_le_mul x y

lemma add_fixedSeed_lip (a : ℝ) (C T : Expression X d) {k q : ℕ}
    (M : Program (Point d × (Fin k → Point d)) d q (Point d))
    (P : (Fin k → Point d) → (Fin k → Point d)) (hP : Measurable P)
    (V : Point d → ℝ) {K L J : ℝ≥0}
    (hC : FixedSeedLip C V K) (hT : FixedSeedLip T V J)
    (hM : ∀g,LipschitzWith L (fun x => M.run V (x,g))) :
    FixedSeedLip (add a C k q M P hP T) V (‖a‖₊*(L*K)+J) := by
  intro g
  have hN := (hM (P (middleBlock g))).comp (hC (leftBlock g))
  have hS : LipschitzWith (‖a‖₊*(L*K)) (fun x =>
      a • M.run V (C.eval V x (leftBlock g),P (middleBlock g))) := by
    apply LipschitzWith.of_dist_le_mul
    intro x y
    rw [dist_smul₀]
    exact (mul_le_mul_of_nonneg_left (hN.dist_le_mul x y) (norm_nonneg a)).trans_eq
      (by simp only [NNReal.coe_mul,coe_nnnorm]; ring)
  exact hS.add (hT (rightBlock g))

lemma FixedSeedLip.compiled {C : Expression X d} {V : Point d → ℝ} {K : ℝ≥0}
    (h : FixedSeedLip C V K) (g : Fin C.slots → Point d) :
    LipschitzWith K (fun x => C.compile.run V (x,g)) := by
  simpa only [compile_run] using h g
end LogConcaveSampling.OracleCompiler.Expression

namespace LogConcaveSampling.SeedCompiler
open OracleCompiler
open scoped NNReal

variable {d : ℕ} {V : Point d → ℝ} {K : ℝ≥0}

lemma terminalMean_fixedSeed_lip (hV : LipschitzWith K (gradient V))
    (r σ : ℝ) (g : Fin 2 → Point d) :
    LipschitzWith K (fun x => (terminalMean d r σ).run V (x,g)) := by
  apply LipschitzWith.of_dist_le_mul
  intro x y
  simp only [terminalMean_run,dist_add_right]
  simpa only [dist_add_right] using hV.dist_le_mul (x+r • g 0) (y+r • g 0)

lemma terminalSample_fixedSeed_lip (hV : LipschitzWith K (gradient V))
    (r η : ℝ) (g : Fin 3 → Point d) :
    LipschitzWith (‖r‖₊*K) (fun x => (terminalSample d r η).run V (x,g)) := by
  apply LipschitzWith.of_dist_le_mul
  intro x y
  simp only [terminalSample_run,dist_add_right,dist_sub_left,dist_smul₀,
    NNReal.coe_mul,coe_nnnorm]
  have hh := hV.dist_le_mul (x+r • g 0) (y+r • g 0)
  rw [dist_add_right] at hh
  nlinarith [mul_le_mul_of_nonneg_left hh (norm_nonneg r)]

end LogConcaveSampling.SeedCompiler

end

end

section

noncomputable section
namespace LogConcaveSampling.OracleCompiler.Expression
open MeasureTheory

variable {E : Type*} [MeasurableSpace E]

lemma split_slots_preserving (μ : Measure E) [SigmaFinite μ] (c k : ℕ) :
    MeasurePreserving
      (fun g : Fin (c+k) → E =>
        ((fun i : Fin c => g (Fin.castAdd k i)),fun i : Fin k => g (Fin.natAdd c i)))
      (Measure.pi fun _ => μ) ((Measure.pi fun _ : Fin c => μ).prod (Measure.pi fun _ : Fin k => μ)) := by
  have H := (measurePreserving_sumPiEquivProdPi (fun _ : Fin c ⊕ Fin k => μ)).comp
    (measurePreserving_piCongrLeft (fun _ : Fin (c+k) => μ) finSumFinEquiv).symm
  convert H using 1
  rfl

lemma three_blocks_preserving (μ : Measure E) [SigmaFinite μ] (c k t : ℕ) :
    MeasurePreserving
      (fun g : Fin (c+(k+t)) → E =>
        ((fun i : Fin c => g (Fin.castAdd (k+t) i)),
          ((fun i : Fin k => g (Fin.natAdd c (Fin.castAdd t i))),
            fun i : Fin t => g (Fin.natAdd c (Fin.natAdd k i)))))
      (Measure.pi fun _ => μ)
      ((Measure.pi fun _ : Fin c => μ).prod
        ((Measure.pi fun _ : Fin k => μ).prod (Measure.pi fun _ : Fin t => μ))) := by
  exact ((MeasurePreserving.id (Measure.pi fun _ : Fin c => μ)).prod
    (split_slots_preserving μ k t)).comp (split_slots_preserving μ c (k+t))

lemma three_blocks_with_anchor {A : Type*} [MeasurableSpace A] (ν : Measure A) [SFinite ν]
    (μ : Measure E) [SigmaFinite μ] (c k t : ℕ) :
    (ν.prod (Measure.pi fun _ : Fin (c+(k+t)) => μ)).map
      (fun z => (z.1,
        ((fun i : Fin c => z.2 (Fin.castAdd (k+t) i)),
          ((fun i : Fin k => z.2 (Fin.natAdd c (Fin.castAdd t i))),
            fun i : Fin t => z.2 (Fin.natAdd c (Fin.natAdd k i))))))=
      ν.prod ((Measure.pi fun _ : Fin c => μ).prod
        ((Measure.pi fun _ : Fin k => μ).prod (Measure.pi fun _ : Fin t => μ))) := by
  exact ((MeasurePreserving.id ν).prod (three_blocks_preserving μ c k t)).map_eq

end LogConcaveSampling.OracleCompiler.Expression

end

end

end

end OAI