import Mathlib
import OAI.Probability.Ballisticity.Estimates.BufferTree

namespace OAI

section

section

open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal NNReal BigOperators Topology Classical
namespace DirectionalTransience

lemma buffer_log_recurrence {Ω : Type*} (B : ℕ → Set Ω) (ω : Ω)
    (R : ℕ → ℝ) (hR : ∀ n, 0 < R n) (A D : ℝ)
    (hstep : ∀ n, R n * Real.exp (if ω ∈ B n then A else -D) ≤ R (n+1)) (n : ℕ) :
    Real.log (R n)+(if ω ∈ B n then A else -D) ≤ Real.log (R (n+1)) := by
  have hp : 0 < R n * Real.exp (if ω ∈ B n then A else -D) := mul_pos (hR n) (Real.exp_pos _)
  have hh := Real.log_le_log hp (hstep n)
  rwa [Real.log_mul (hR n).ne' (Real.exp_pos _).ne',Real.log_exp] at hh

lemma buffer_log_sum {Ω : Type*} (B : ℕ → Set Ω) (ω : Ω)
    (R : ℕ → ℝ) (hR : ∀ n, 0 < R n) (A D : ℝ)
    (hstep : ∀ n, R n * Real.exp (if ω ∈ B n then A else -D) ≤ R (n+1)) (n : ℕ) :
    Real.log (R 0) + successes B n ω*(A+D) - (n:ℝ)*D ≤ Real.log (R n) := by
  induction n with
  | zero => simp [successes]
  | succ n ih =>
    have hh := buffer_log_recurrence B ω R hR A D hstep n
    rw [successes_succ,Nat.cast_add,Nat.cast_one]
    by_cases hb : ω ∈ B n
    · simp only [ite_eq_left hb] at hh ⊢
      nlinarith
    · simp only [ite_eq_right hb] at hh ⊢
      nlinarith

lemma buffer_log_growth {Ω : Type*} (B : ℕ → Set Ω) (ω : Ω)
    (R : ℕ → ℝ) (hR : ∀ n, 0 < R n) {A s W : ℝ} (hA : 0 ≤ A) (hs : 0 ≤ s)
    (hstep : ∀ n, R n * Real.exp (if ω ∈ B n then A else -(s*A/8)) ≤ R (n+1))
    (hexcess : ∀ n : ℕ, s/4*(n:ℝ)-successes B n ω ≤ W) (n : ℕ) :
    Real.log (R 0) + (s*A/8)*(n:ℝ) - W*(A+s*A/8) ≤ Real.log (R n) := by
  have hh := buffer_log_sum B ω R hR A (s*A/8) hstep n
  have hAD : 0 ≤ A+s*A/8 := by positivity
  have hc := mul_le_mul_of_nonneg_right (hexcess n) hAD
  have hn : 0 ≤ s*s*A*(n:ℝ) := by positivity
  nlinarith

lemma buffer_stage_count {Ω : Type*} (B : ℕ → Set Ω) (ω : Ω)
    (R : ℕ → ℝ) (hR : ∀ n, 0 < R n) {A s W C : ℝ} (hA : 0 ≤ A) (hs : 0 ≤ s)
    (hstep : ∀ n, R n * Real.exp (if ω ∈ B n then A else -(s*A/8)) ≤ R (n+1))
    (hexcess : ∀ n : ℕ, s/4*(n:ℝ)-successes B n ω ≤ W)
    (hR0 : 1 ≤ R 0) (hC : 0 < C) (n H : ℕ) (hheight : R n ≤ C*(H+1)) :
    (s*A/8)*(n:ℝ) ≤ Real.log C + Real.log ((H:ℝ)+1) + W*(A+s*A/8) := by
  have hl := buffer_log_growth B ω R hR hA hs hstep hexcess n
  have hu := Real.log_le_log (hR n) hheight
  have hH : 0 < (H:ℝ)+1 := by positivity
  rw [Real.log_mul hC.ne' hH.ne'] at hu
  have h0 := Real.log_nonneg hR0
  linarith

lemma buffer_contraction_choice {α s : ℝ} (hα : 0 < α) (hs : 0 < s) :
    let ε := 1-Real.exp (-(s*Real.log (1+α)/8))
    0 < ε ∧ ε < 1 ∧ Real.exp (Real.log (1+α))=1+α ∧
      Real.exp (-(s*Real.log (1+α)/8))=1-ε := by
  have hA : 0 < Real.log (1+α) := Real.log_pos (by linarith)
  have hd : 0 < s*Real.log (1+α)/8 := by positivity
  have he := Real.exp_lt_one_iff.mpr (show -(s*Real.log (1+α)/8)<0 by linarith)
  have hep := Real.exp_pos (-(s*Real.log (1+α)/8))
  dsimp only
  refine ⟨by linarith,by linarith,Real.exp_log (by linarith),by ring⟩
end DirectionalTransience

end

section

open MeasureTheory ProbabilityTheory Filter Function
open scoped ENNReal NNReal BigOperators Topology Classical
namespace DirectionalTransience

noncomputable def bufferCurrentNode {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1)
    (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r)
    (root : AdaptedBufferNode e) (ω : Environment d) (n : ℕ) : AdaptedBufferNode e :=
  bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root (bufferHistory e f hef R₀ z₀ ε α g κ H hH root ω n)

lemma bufferCurrentNode_succ {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1)
    (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r)
    (root : AdaptedBufferNode e) (ω : Environment d) (n : ℕ) :
    let N := bufferCurrentNode e f hef R₀ z₀ ε α g κ H hH root ω n
    let p := bufferNodeDecision e f z₀ ε α g H N ω
    bufferCurrentNode e f hef R₀ z₀ ε α g κ H hH root ω (n+1) =
      bufferChildNode e f hef R₀ z₀ ε α g κ N (H N.radius) (hH N.radius) p.1 p.2 := rfl

lemma bufferNextRadius_exponential_step (R₀ r ε α A D : ℝ)
    (hα : Real.exp A=1+α) (hε : Real.exp (-D)=1-ε) (b : Bool) :
    r*Real.exp (if b then A else -D) ≤ bufferNextRadius R₀ r ε α b := by
  cases b <;> simp only [Bool.false_eq_true,↓reduceIte,bufferNextRadius,hα,hε]
  · simpa only [mul_comm] using (le_max_right R₀ ((1-ε)*r))
  · simpa only [mul_comm] using (le_max_right R₀ ((1+α)*r))

lemma bufferCurrentNode_exponential_step {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1)
    (R₀ z₀ ε α g A D : ℝ) (hα : Real.exp A=1+α) (hε : Real.exp (-D)=1-ε)
    (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r)
    (root : AdaptedBufferNode e) (ω : Environment d) (hr : ω ∈ root.active) (n : ℕ) :
    (bufferCurrentNode e f hef R₀ z₀ ε α g κ H hH root ω n).radius *
      Real.exp (if ω ∈ bufferTreeSuccess e f hef R₀ z₀ ε α g κ H hH root n then A else -D) ≤
      (bufferCurrentNode e f hef R₀ z₀ ε α g κ H hH root ω (n+1)).radius := by
  rw [bufferCurrentNode_succ]
  have hb := bufferTreeSuccess_iff_decision e f hef R₀ z₀ ε α g κ H hH root ω hr n
  rw [hb]
  let N := bufferCurrentNode e f hef R₀ z₀ ε α g κ H hH root ω n
  have he := bufferNextRadius_exponential_step R₀ N.radius ε α A D hα hε
    (bufferNodeDecision e f z₀ ε α g H N ω).2
  convert he using 1
  · congr 2
    exact congrArg (fun h : Decidable ((bufferNodeDecision e f z₀ ε α g H N ω).2=true) =>
      @ite ℝ _ h A (-D)) (Subsingleton.elim _ _)
  · rfl

lemma bufferCurrentNode_log_growth {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1)
    {R₀ α s : ℝ} (hR₀ : 0 < R₀) (hα : 0 < α) (hs : 0 < s)
    (z₀ g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r)
    (root : AdaptedBufferNode e) (hroot : root.radius=R₀) (ω : Environment d) (hr : ω ∈ root.active)
    (W : ℝ)
    (hexcess : ∀ n : ℕ, s/4*(n:ℝ)-successes
      (bufferTreeSuccess e f hef R₀ z₀ (1-Real.exp (-(s*Real.log (1+α)/8))) α g κ H hH root) n ω ≤ W)
    (n : ℕ) :
    Real.log R₀+(s*Real.log (1+α)/8)*(n:ℝ)-W*(Real.log (1+α)+s*Real.log (1+α)/8) ≤
      Real.log (bufferCurrentNode e f hef R₀ z₀ (1-Real.exp (-(s*Real.log (1+α)/8))) α g κ H hH root ω n).radius := by
  let ε := 1-Real.exp (-(s*Real.log (1+α)/8))
  let R := fun n => (bufferCurrentNode e f hef R₀ z₀ ε α g κ H hH root ω n).radius
  have hp (n : ℕ) : 0 < R n := hR₀.trans_le
    (bufferNodeAt_radius e f hef R₀ z₀ ε α g κ H hH root hroot.ge _)
  have hc := buffer_contraction_choice hα hs
  have he := bufferCurrentNode_exponential_step e f hef R₀ z₀ ε α g
    (Real.log (1+α)) (s*Real.log (1+α)/8) hc.2.2.1 hc.2.2.2 κ H hH root ω hr
  have hA : 0 ≤ Real.log (1+α) := (Real.log_pos (by linarith)).le
  have hh := buffer_log_growth
    (bufferTreeSuccess e f hef R₀ z₀ ε α g κ H hH root) ω R hp hA hs.le he hexcess n
  have hr0 : R 0=R₀ := hroot
  rw [hr0] at hh
  exact hh
end DirectionalTransience

end

end

end OAI