import Mathlib
import OAI.Probability.GaussianRegression.Main
import OAI.Probability.MemoryPrecision.SuccessArithmetic

namespace OAI

open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise

noncomputable section
universe u v


open MeasureTheory ProbabilityTheory Set Filter
open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
namespace MemoryPrecision

def StreamConstant : ℝ := 3*(SuccessConstant+21)
lemma streamConstant_pos : 0 < StreamConstant := by
  have h := successConstant_one
  dsimp [StreamConstant]
  linarith

lemma blockCount_antitone {p q : ℕ} (hq : 0 < q) (hqp : q ≤ p) (T : ℕ) :
    BlockCount T p ≤ BlockCount T q := by
  apply Nat.ceil_mono
  exact div_le_div_of_nonneg_left (by positivity) (by exact_mod_cast hq) (by exact_mod_cast hqp)

lemma power_le_exp {x : ℝ} (hx : 0 ≤ x) (d : ℕ) : x^d ≤ Real.exp (x*d) := by
  have hl : x ≤ Real.exp x := by linarith [Real.add_one_le_exp x]
  have h := pow_le_pow_left₀ hx hl d
  simpa only [← Real.rpow_natCast, ← Real.exp_mul] using h

lemma stream_root_exp {d M : ℕ} (hd : 32 ≤ d) :
    (((d/8+2)*2^M:ℕ):ℝ)^(1/((d/8:ℕ):ℝ)) ≤ Real.exp ((d:ℝ)+16*M/d) := by
  have hn : (d/8+2)*2^M ≤ 2^(d+M) := by
    have h : d/8+2 ≤ 2^d := (show d/8+2 ≤ d+1 by omega).trans Nat.lt_two_pow_self
    simpa [pow_add] using Nat.mul_le_mul_right (2^M) h
  have ht : (2:ℝ) ≤ Real.exp 1 := by linarith [Real.add_one_le_exp (1:ℝ)]
  have hnum : (((d/8+2)*2^M:ℕ):ℝ) ≤ Real.exp ((d:ℝ)+M) := by
    calc
      _ ≤ (2:ℝ)^(d+M) := by exact_mod_cast hn
      _ ≤ (Real.exp 1)^(d+M) := pow_le_pow_left₀ (by norm_num) ht _
      _ = _ := by rw [← Real.rpow_natCast, ← Real.exp_mul]; simp
  have hdp : (d:ℝ)/16 ≤ (d/8:ℕ) := by
    apply (div_le_iff₀ (by norm_num : (0:ℝ) < 16)).2
    exact_mod_cast (show d ≤ (d/8)*16 by omega)
  have hd0 : (0:ℝ) < d := by exact_mod_cast (show 0 < d by omega)
  have hr : ((d:ℝ)+M)/((d/8:ℕ):ℝ) ≤ (d:ℝ)+16*M/d := by
    calc
      _ ≤ ((d:ℝ)+M)/((d:ℝ)/16) := div_le_div_of_nonneg_left (by positivity) (by positivity) hdp
      _ = 16+16*M/d := by field_simp
      _ ≤ _ := by
        have : (16:ℝ) ≤ d := by exact_mod_cast (show 16 ≤ d by omega)
        linarith
  calc
    _ ≤ (Real.exp ((d:ℝ)+M))^(1/((d/8:ℕ):ℝ)) :=
      Real.rpow_le_rpow (by positivity) hnum (by positivity)
    _ = Real.exp (((d:ℝ)+M)/((d/8:ℕ):ℝ)) := by rw [← Real.exp_mul]; congr 1; ring
    _ ≤ _ := Real.exp_le_exp.mpr hr

lemma stream_step_exp {d M : ℕ} (hd : 32 ≤ d) :
    SuccessConstant^d * (((d/8+2)*2^M:ℕ):ℝ)^(1/((d/8:ℕ):ℝ)) ≤
      Real.exp ((d:ℝ)*(SuccessConstant+1)+16*M/d) := by
  have hS := successConstant_one
  calc
    _ ≤ Real.exp (SuccessConstant*d) * Real.exp ((d:ℝ)+16*M/d) :=
      mul_le_mul (power_le_exp (by linarith) d) (stream_root_exp hd) (by positivity) (by positivity)
    _ = _ := by rw [← Real.exp_add]; congr 1; ring

lemma stream_step_one (d M : ℕ) :
    1 ≤ SuccessConstant^d * (((d/8+2)*2^M:ℕ):ℝ)^(1/((d/8:ℕ):ℝ)) := by
  apply one_le_mul_of_one_le_of_one_le (one_le_pow₀ successConstant_one)
  apply Real.one_le_rpow _ (by positivity)
  exact_mod_cast (show 1 ≤ (d/8+2)*2^M by
    exact Nat.succ_le_iff.mpr (Nat.mul_pos (by omega) (by positivity)))

lemma stream_exponent_bound {d M : ℕ} (hd : 32 ≤ d) :
    (d:ℝ)*(SuccessConstant+5)+16*M/d ≤
      (((d:ℝ)-1)/2)*StreamConstant*(1+(M:ℝ)/(d:ℝ)^2) := by
  have hS := successConstant_one
  have hd0 : (0:ℝ) < d := by exact_mod_cast (show 0 < d by omega)
  have hd3 : (d:ℝ)/3 ≤ ((d:ℝ)-1)/2 := by
    have : (32:ℝ) ≤ d := by exact_mod_cast hd
    linarith
  have hc : 0 ≤ StreamConstant := streamConstant_pos.le
  calc
    _ ≤ (SuccessConstant+21)*(d:ℝ)+(SuccessConstant+21)*(M/d) := by
      have hM : 0 ≤ (M:ℝ)/d := by positivity
      have hm := mul_le_mul_of_nonneg_right (show (16:ℝ) ≤ SuccessConstant+21 by linarith) hM
      have hn : (d:ℝ)*(SuccessConstant+5) ≤ (SuccessConstant+21)*(d:ℝ) := by nlinarith
      simpa only [mul_div_assoc] using add_le_add hn hm
    _ = (d:ℝ)/3*StreamConstant*(1+(M:ℝ)/(d:ℝ)^2) := by
      dsimp [StreamConstant]
      field_simp
    _ ≤ _ := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right hd3 hc) (by positivity)

lemma stream_full_factor {d M T : ℕ} (hd : 32 ≤ d) (hT : 0 < T) :
    (4:ℝ)^d * (SuccessConstant^d * (((d/8+2)*2^M:ℕ):ℝ)^(1/((d/8:ℕ):ℝ)))^BlockCount T (d/8) ≤
      Real.exp ((((d:ℝ)-1)/2)*StreamConstant*(1+(M:ℝ)/(d:ℝ)^2)*(BlockCount T ((d-1)/8):ℝ)) := by
  let b := BlockCount T ((d-1)/8)
  let K := SuccessConstant^d * (((d/8+2)*2^M:ℕ):ℝ)^(1/((d/8:ℕ):ℝ))
  have hK : 1 ≤ K := stream_step_one d M
  have hb : 1 ≤ b := blockCount_pos hT (by omega)
  have hbp : BlockCount T (d/8) ≤ b := blockCount_antitone (by omega) (by omega) T
  have h4 : (4:ℝ)^d ≤ Real.exp (4*d*(b:ℝ)) := by
    apply (power_le_exp (by norm_num : (0:ℝ) ≤ 4) d).trans
    apply Real.exp_le_exp.mpr
    exact le_mul_of_one_le_right (by positivity) (by exact_mod_cast hb)
  have hpow : K^b ≤ Real.exp (((d:ℝ)*(SuccessConstant+1)+16*M/d)*(b:ℝ)) := by
    have h := pow_le_pow_left₀ (by linarith : 0 ≤ K) (stream_step_exp hd) b
    simpa only [← Real.rpow_natCast, ← Real.exp_mul, K] using h
  calc
    _ ≤ (4:ℝ)^d * K^b := mul_le_mul_of_nonneg_left (pow_le_pow_right₀ hK hbp) (by positivity)
    _ ≤ Real.exp (4*d*(b:ℝ)) * Real.exp (((d:ℝ)*(SuccessConstant+1)+16*M/d)*(b:ℝ)) :=
      mul_le_mul h4 hpow (by positivity) (by positivity)
    _ = Real.exp (((d:ℝ)*(SuccessConstant+5)+16*M/d)*(b:ℝ)) := by rw [← Real.exp_add]; congr 1; ring
    _ ≤ _ := Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_right (stream_exponent_bound hd) (by positivity))

end MemoryPrecision


end

end OAI