import Mathlib
import OAI.Probability.LogConcave.Numerics.RowGaussian

namespace OAI

section
noncomputable section
namespace LogConcaveSampling.MeanTree
open MeasureTheory OracleCompiler OracleCompiler.Expression SeedCompiler
open scoped Classical BigOperators

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

def cost : MeanTree X d → ℕ
  | .node _ _ _ _ _ C => ∑i,(1+cost (C i))

@[simp] lemma cost_anchor (b : X → Point d) (hb : Measurable b) : cost (anchor b hb)=0 := by simp [cost,anchor]
@[simp] lemma cost_zero : cost (zero : MeanTree X d)=0 := by simp [zero]
@[simp] lemma cost_scale (s : ℝ) (E : MeanTree X d) : cost (scale s E)=cost E := by cases E; rfl
@[simp] lemma cost_add (E D : MeanTree X d) : cost (add E D)=cost E+cost D := by
  cases E; cases D
  simp only [cost,add,Fin.sum_univ_add,Fin.addCases_left,Fin.addCases_right]
@[simp] lemma cost_mean (r : ℝ) (E : MeanTree X d) : cost (mean r E)=1+cost E := by simp [cost,mean]
@[simp] lemma cost_conditional (r ρ : ℝ) (E D : MeanTree X d) : cost (conditional r ρ E D)=1+cost E+cost D := by
  simp [conditional,Nat.add_assoc]
@[simp] lemma cost_sumFin (k : ℕ) (E : Fin k → MeanTree X d) : cost (sumFin k E)=∑i,cost (E i) := by
  induction k with
  | zero => simp [sumFin]
  | succ k ih => simp [sumFin,ih,Fin.sum_univ_succ]
@[simp] lemma cost_sumFamily {I : Type*} [Fintype I] (E : I → MeanTree X d) :
    cost (sumFamily E)=∑i,cost (E i) := by
  rw [sumFamily,cost_sumFin]
  exact Fintype.sum_equiv (Fintype.equivFin I).symm _ _ (fun _ => rfl)

theorem compileDeclared_size (D A : ℝ) (P : ℝ → ℝ → Prop) (M : ℝ → ℝ → SeedProgram d)
    (S Q : ℕ) (hM : ∀r τ,P r τ → (M r τ).slots≤S ∧ (M r τ).calls≤Q)
    (E : MeanTree X d) (n : ℝ) (hready : ShiftReady D A P E n) :
    (compileDeclared D A M E n).slots≤1+cost E*(S+1) ∧
      (compileDeclared D A M E n).calls≤cost E*Q := by
  induction E generalizing n with | node k b hb a r C ih =>
    have hc (i) := ih i (r i/(2*D)) (hready i).2.2
    have hm (i) := hM (r i) (declaredNoise n A) (hready i).2.1
    constructor
    · simp only [compileDeclared,slots_compileTerms,Expression.slots,cost]
      apply Nat.add_le_add_left
      rw [Finset.sum_mul]
      apply Finset.sum_le_sum
      intro i _
      have h₁ := (hc i).1
      have h₂ := (hm i).1
      nlinarith
    · simp only [calls_compileDeclared,cost,Finset.sum_mul]
      apply Finset.sum_le_sum
      intro i _
      have h₁ := (hc i).2
      have h₂ := (hm i).2
      nlinarith

def DriftBound (R : ℝ) : (E : MeanTree X d) → DriftData E → Prop
  | .node _ _ _ _ r C,p => ∀i,|((p.2 i).root (C i))/(r i)|≤R ∧ DriftBound R (C i) (p.2 i)

theorem compileDeclaredShift_energy_bound {D A R B : ℝ} (hD : 0<D) (_hR : 0≤R) (hB : 0≤B)
    (P : ℝ → ℝ → Prop) (M : ℝ → ℝ → SeedProgram d)
    (hv : ∀r τ,P r τ → (∑j,(M r τ).shift j^2)≤D^2)
    (hBv : ∀r τ,P r τ → (∑j,(M r τ).shift j^2)≤B)
    (E : MeanTree X d) (n : ℝ) (p : DriftData E)
    (hready : ShiftReady D A P E n) (hg : DriftBound R E p) :
    (∑j,compileDeclaredShift D A M E n p j^2)≤(cost E:ℝ)*(4*R^2*B) := by
  induction E generalizing n with | node k b hb a r C ih =>
    change (∑j,compileTermsShift D k a (fun i => compileDeclared D A M (C i) (r i/(2*D)))
      (fun i => M (r i) (declaredNoise n A)) (.noise b hb (declaredReserve n A a))
      (fun i => compileDeclaredShift D A M (C i) (r i/(2*D)) (p.2 i))
      (fun i => inverseChildShift D (r i) ((p.2 i).root (C i)) (M (r i) (declaredNoise n A)))
      (fun _ => 0) j^2)≤_
    rw [compileTermsShift_energy]
    simp only [zero_pow (by decide : (2:ℕ)≠0),Finset.sum_const_zero,zero_add,cost,Nat.cast_sum,Nat.cast_add,Nat.cast_one,Finset.sum_mul]
    apply Finset.sum_le_sum
    intro i _
    have hc := ih i (r i/(2*D)) (p.2 i) (hready i).2.2 (hg i).2
    have hi := inverse_shift_energy (fun j => (M (r i) (declaredNoise n A)).shift j/(2*D))
      (M (r i) (declaredNoise n A)).shift (normalized_shift_bound hD _ (hv _ _ (hready i).2.1))
      (((p.2 i).root (C i))/(r i))
    have hs := hBv _ _ (hready i).2.1
    have hh : (((p.2 i).root (C i))/(r i))^2≤R^2 := by
      have hb := pow_le_pow_left₀ (abs_nonneg _) (hg i).1 2
      simpa only [sq_abs] using hb
    have hm := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hh (by norm_num : (0:ℝ)≤4)) hB
    have hv' := mul_le_mul_of_nonneg_left hs (show 0≤4*(((p.2 i).root (C i))/(r i))^2 by positivity)
    change (∑j,compileDeclaredShift D A M (C i) (r i/(2*D)) (p.2 i) j^2)+
      (∑j,inverseChildShift D (r i) ((p.2 i).root (C i)) (M (r i) (declaredNoise n A)) j^2)≤_
    change (∑j,inverseChildShift D (r i) ((p.2 i).root (C i)) (M (r i) (declaredNoise n A)) j^2)≤_ at hi
    nlinarith
end LogConcaveSampling.MeanTree

end

end

section

noncomputable section
namespace LogConcaveSampling.MeanTree
open Set MeasureTheory
open scoped Classical BigOperators

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

lemma sqrt_one_sub_sq_gap {ρ : ℝ} (hρ : ρ∈Icc (0:ℝ) 1) :
    1-ρ≤Real.sqrt (1-ρ^2) := by
  have hp : 0≤1-ρ^2 := by nlinarith [hρ.1,hρ.2]
  have hs := Real.sq_sqrt hp
  nlinarith [Real.sqrt_nonneg (1-ρ^2),hρ.1,hρ.2]

lemma mean_direct_ratio {ρ T θ : ℝ} (hT : 1/2≤T) (hT1 : T<1)
    (hρ : ρ∈Icc (0:ℝ) T) (hθ : θ^2≤Real.sqrt (1-T^2)) :
    0<Real.sqrt (1-ρ^2) ∧ |(1-ρ*Real.cos θ/T)/Real.sqrt (1-ρ^2)|≤3 := by
  have hT0 : 0<T := by linarith
  have hρ1 : ρ<1 := hρ.2.trans_lt hT1
  have hp : 0<1-ρ^2 := by nlinarith [hρ.1]
  have hs : 0<Real.sqrt (1-ρ^2) := Real.sqrt_pos.mpr hp
  have hc := Real.one_sub_sq_div_two_le_cos (x:=θ)
  have hcos := Real.cos_le_one θ
  have hn : 0≤1-ρ*Real.cos θ/T := by
    rw [sub_nonneg,div_le_iff₀ hT0,one_mul]
    exact (mul_le_mul_of_nonneg_left hcos hρ.1).trans (by simpa using hρ.2)
  have hτ := sqrt_one_sub_sq_gap ⟨hρ.1,hρ1.le⟩
  have hθ' : θ^2≤Real.sqrt (1-ρ^2) := hθ.trans (Real.sqrt_le_sqrt (by nlinarith [hρ.1,hρ.2]))
  have hr : ρ*Real.cos θ≥ρ*(1-θ^2/2) := mul_le_mul_of_nonneg_left hc hρ.1
  have hd : (1-ρ*Real.cos θ/T)≤3*Real.sqrt (1-ρ^2) := by
    have hm₁ := mul_le_mul_of_nonneg_left hθ' hρ.1
    have hm₂ := mul_le_mul_of_nonneg_right hρ.2 (Real.sqrt_nonneg (1-ρ^2))
    have hm₃ := mul_le_mul_of_nonneg_right hT (Real.sqrt_nonneg (1-ρ^2))
    have hnum : T-ρ*Real.cos θ≤3*Real.sqrt (1-ρ^2)*T := by nlinarith
    calc
      1-ρ*Real.cos θ/T=(T-ρ*Real.cos θ)/T := by rw [sub_div,div_self hT0.ne']
      _≤3*Real.sqrt (1-ρ^2) := (div_le_iff₀ hT0).mpr hnum
  refine ⟨hs,?_⟩
  rw [abs_of_nonneg (div_nonneg hn hs.le),div_le_iff₀ hs]
  exact hd

lemma sample_direct_ratio {ρ T : ℝ} (_hT : 0≤T) (hT1 : T<1) (hρ : ρ∈Icc (0:ℝ) T) :
    0<Real.sqrt (1-ρ^2) ∧ |(1-ρ*T)/Real.sqrt (1-ρ^2)|≤2 := by
  have hρ1 : ρ<1 := hρ.2.trans_lt hT1
  have hp : 0<1-ρ^2 := by nlinarith [hρ.1]
  have hs : 0<Real.sqrt (1-ρ^2) := Real.sqrt_pos.mpr hp
  have hn : 0≤1-ρ*T := by nlinarith [hρ.1,mul_nonneg hρ.1 (sub_nonneg.mpr hT1.le)]
  have hτ := sqrt_one_sub_sq_gap ⟨hρ.1,hρ1.le⟩
  refine ⟨hs,?_⟩
  rw [abs_of_nonneg (div_nonneg hn hs.le),div_le_iff₀ hs]
  nlinarith [mul_nonneg hρ.1 (sub_nonneg.mpr hρ.2),sq_nonneg (1-ρ)]

theorem exists_driftData (f : Point d → X → X) (R : ℝ) (E : MeanTree X d) (c : ℝ)
    (hc : ∀Δ z,base E (f Δ z)=base E z+c • Δ)
    (hE : centers (fun r b => ∃c : ℝ,(∀Δ z,b (f Δ z)=b z+c • Δ) ∧ |c/r|≤R) E) :
    ∃p : DriftData E,DriftValid f E p ∧ p.root E=c ∧ DriftBound R E p := by
  induction E generalizing c with | node k b hb a r C ih =>
    choose c' hshift hratio using fun i => (hE i).1
    have hh (i : Fin k) := ih i (c' i) (hshift i) (hE i).2
    choose p hp hroot hbound using hh
    exact ⟨(c,p),⟨hc,hp⟩,rfl,fun i => ⟨by simpa only [hroot i] using hratio i,hbound i⟩⟩

omit [MeasurableSpace X] in
lemma DirectCenter.shift {r T v α r' : ℝ} {x Y G b : X → Point d}
    (f : Point d → X → X)
    (hx : ∀Δ z,x (f Δ z)=x z+r • Δ)
    (hY : ∀Δ z,Y (f Δ z)=Y z-α • Δ)
    (hG : ∀Δ z,G (f Δ z)=G z)
    (hb : DirectCenter r T v x Y G r' b) :
    ∃ρ∈Icc (0:ℝ) T,∃θ,|θ|≤v ∧ r'=r*Real.sqrt (1-ρ^2) ∧
      ∀Δ z,b (f Δ z)=b z+(r*(1-ρ*Real.cos θ*α)) • Δ := by
  obtain ⟨ρ,hρ,θ,hθ,hr,hb⟩ := hb
  refine ⟨ρ,hρ,θ,hθ,hr,?_⟩
  intro Δ z
  rw [hb]
  simp only [hx,hY,hG,oriented,smul_add,smul_sub,smul_smul]
  module

omit [MeasurableSpace X] in
lemma DirectCenter.mean_shift {r T v r' : ℝ} (hr : 0<r) (hT : 1/2≤T) (hT1 : T<1)
    (hv : v^2≤Real.sqrt (1-T^2)) {x Y G b : X → Point d}
    (f : Point d → X → X)
    (hx : ∀Δ z,x (f Δ z)=x z+r • Δ)
    (hY : ∀Δ z,Y (f Δ z)=Y z-T⁻¹ • Δ)
    (hG : ∀Δ z,G (f Δ z)=G z)
    (hb : DirectCenter r T v x Y G r' b) :
    0<r' ∧ ∃c : ℝ,(∀Δ z,b (f Δ z)=b z+c • Δ) ∧ |c/r'|≤3 := by
  obtain ⟨ρ,hρ,θ,hθ,hr',hshift⟩ := hb.shift f hx hY hG
  have hθ' : θ^2≤Real.sqrt (1-T^2) := by
    have hpow := pow_le_pow_left₀ (abs_nonneg θ) hθ 2
    simp only [sq_abs] at hpow
    exact hpow.trans hv
  obtain ⟨hτ,hbound⟩ := mean_direct_ratio hT hT1 hρ hθ'
  refine ⟨hr' ▸ mul_pos hr hτ,r*(1-ρ*Real.cos θ*T⁻¹),hshift,?_⟩
  rw [hr',mul_div_mul_left _ _ hr.ne']
  simpa only [div_eq_mul_inv] using hbound
end LogConcaveSampling.MeanTree

end

end

section

noncomputable section
namespace LogConcaveSampling.MeanTree
open Set MeasureTheory Quadrature
open scoped Classical BigOperators

variable {d : ℕ}

abbrev MeanInput (d : ℕ) := Point d × (Point d × Point d)
abbrev SampleInput (d : ℕ) := Point d × Point d

def meanInputMove (r T : ℝ) (Δ : Point d) (z : MeanInput d) : MeanInput d :=
  (z.1+r • Δ,(z.2.1-T⁻¹ • Δ,z.2.2))
def sampleInputMove (r T : ℝ) (Δ : Point d) (z : SampleInput d) : SampleInput d :=
  (z.1+r • Δ,z.2-T • Δ)

def literalMean (r T h ψ σ : ℝ) (n m N nc Nc : ℕ) (e : ProbabilityNode T h (n+1)) :
    MeanTree (MeanInput d) d :=
  meanCircuit r T h ψ (σ/2) n m N nc Nc e
    (anchor Prod.fst (by fun_prop)) (anchor (fun z => z.2.1) (by fun_prop))
    (anchor (fun z => z.2.2) (by fun_prop))

def literalSample (r T h : ℝ) (n N : ℕ) (e : ProbabilityNode T h n) :
    MeanTree (SampleInput d) d :=
  scale T⁻¹ (forward r T h n N (anchor Prod.fst (by fun_prop))
    (anchor Prod.snd (by fun_prop)) e)

lemma literalMean_geometry {r T h ψ σ v : ℝ} {n m N nc Nc : ℕ}
    (hT : 0<T) (hT1 : T<1) (hh : 0<h) (hv : 0≤v)
    (hψ : ∀j : Fin (m+1),|ψ*angleNodes m j|≤v) (e : ProbabilityNode T h (n+1)) :
    base (literalMean (d:=d) r T h ψ σ n m N nc Nc e)=(fun z => (σ/2) • z.2.2) ∧
    centers (DirectCenter r T v Prod.fst (fun z : MeanInput d => z.2.1) (fun z => z.2.2))
      (literalMean r T h ψ σ n m N nc Nc e) := by
  exact meanCircuit_centers_direct hT hT1 hh hv _ _ _ rfl rfl rfl hψ
    (centers_anchor _ _ _) (centers_anchor _ _ _) (centers_anchor _ _ _) e

lemma literalSample_geometry {r T h : ℝ} {n N : ℕ} (hn : 0<n)
    (hT : 0<T) (hT1 : T<1) (hh : 0<h) (e : ProbabilityNode T h n) :
    base (literalSample (d:=d) r T h n N e)=(fun z => T⁻¹ • z.2) ∧
    centers (DirectCenter r T 0 Prod.fst Prod.snd (fun _ : SampleInput d => 0))
      (literalSample r T h n N e) := by
  have hg := forward_centers_direct (r:=r) (N:=N) (v:=0) (θ:=0) (x:=Prod.fst) (Y:=Prod.snd) (G:=fun _ : SampleInput d => 0) hn hT hT1 hh
    (anchor (Prod.fst : SampleInput d → Point d) (by fun_prop)) (anchor Prod.snd (by fun_prop))
    rfl (by simp only [base_anchor,oriented_zero]) (by norm_num) (centers_anchor _ _ _) (centers_anchor _ _ _) e
  exact ⟨by simp only [literalSample,base_scale,hg.1,base_anchor],
    (centers_scale _ _ _).2 hg.2⟩

theorem literalMean_drift {r T h ψ σ v : ℝ} {n m N nc Nc : ℕ}
    (hr : 0<r) (hT : 1/2≤T) (hT1 : T<1) (hh : 0<h) (hv : 0≤v)
    (hvsmall : v^2≤Real.sqrt (1-T^2))
    (hψ : ∀j : Fin (m+1),|ψ*angleNodes m j|≤v) (e : ProbabilityNode T h (n+1)) :
    ∃p : DriftData (literalMean (d:=d) r T h ψ σ n m N nc Nc e),
      DriftValid (meanInputMove r T) _ p ∧ p.root _=0 ∧ DriftBound 3 _ p := by
  have hg := literalMean_geometry (d:=d) (r:=r) (σ:=σ) (N:=N) (nc:=nc) (Nc:=Nc)
    (by linarith : 0<T) hT1 hh hv hψ e
  apply exists_driftData (meanInputMove r T) 3 _ 0
  · intro Δ z
    rw [hg.1]
    simp [meanInputMove]
  · apply centers_mono _ (fun r' b hb => ?_) hg.2
    exact (hb.mean_shift hr hT hT1 hvsmall (meanInputMove r T)
      (fun _ _ => rfl) (fun _ _ => rfl) (fun _ _ => rfl)).2

theorem literalSample_drift {r T h : ℝ} {n N : ℕ}
    (hr : 0<r) (hn : 0<n) (hT : 0<T) (hT1 : T<1) (hh : 0<h)
    (e : ProbabilityNode T h n) :
    ∃p : DriftData (literalSample (d:=d) r T h n N e),
      DriftValid (sampleInputMove r T) _ p ∧ p.root _ = -1 ∧ DriftBound 2 _ p := by
  have hg := literalSample_geometry (d:=d) (r:=r) (N:=N) hn hT hT1 hh e
  apply exists_driftData (sampleInputMove r T) 2 _ (-1)
  · intro Δ z
    rw [hg.1]
    simp only [sampleInputMove,smul_sub,smul_smul,inv_mul_cancel₀ hT.ne',one_smul,neg_one_smul]
    rfl
  · apply centers_mono _ (fun r' b hb => ?_) hg.2
    obtain ⟨ρ,hρ,θ,hθ,hr',hshift⟩ := hb.shift (sampleInputMove r T)
      (fun _ _ => rfl) (fun _ _ => rfl) (fun _ _ => rfl)
    have hθ0 : θ=0 := abs_nonpos_iff.mp hθ
    refine ⟨r*(1-ρ*T),?_,?_⟩
    · simpa only [hθ0,Real.cos_zero,mul_one] using hshift
    · rw [hr',mul_div_mul_left _ _ hr.ne']
      exact (sample_direct_ratio hT.le hT1 hρ).2
end LogConcaveSampling.MeanTree

end

end

end OAI