import Mathlib
import OAI.Probability.SKBarriers.Dynamics.BankPool

namespace OAI

section

noncomputable section
open scoped BigOperators
open Classical
namespace SK.Analytic

def bankPrefix (c : ℕ → ℝ) : ℕ → ℝ
  | 0 => 0
  | j+1 => bankPrefix c j+c j+2

 theorem bankPrefix_nonneg (c : ℕ → ℝ) (hc : ∀j,0≤c j) (j : ℕ) : 0≤bankPrefix c j := by
  induction j with
  | zero => exact le_rfl
  | succ j ih => simp only [bankPrefix]; linarith only [ih,hc j]

 theorem bankPrefix_mono (c : ℕ → ℝ) (hc : ∀j,0≤c j) : Monotone (bankPrefix c) := by
  apply monotone_nat_of_le_succ
  intro j
  simp only [bankPrefix]
  linarith only [hc j]

 theorem bankPrefix_cost_le (c : ℕ → ℝ) (hc : ∀j,0≤c j) {j B : ℕ} (hj : j<B) : c j+2≤bankPrefix c B := by
  have h := bankPrefix_mono c hc (show j+1≤B by omega)
  simp only [bankPrefix] at h
  linarith only [h,bankPrefix_nonneg c hc j]

def blockPriorEquiv (p B : ℕ) (j : Fin p) : BankPrior (blockPrior p B) j ≃ Fin (j.val%B) where
  toFun i := ⟨i.val.val-j.val/B*B,by
    have h := (mem_blockPrior p B i.val j).mp i.property
    have hd : j.val%B+j.val/B*B=j.val := by simpa only [Nat.mul_comm] using Nat.mod_add_div j.val B
    omega⟩
  invFun a := ⟨⟨j.val/B*B+a.val,by
    have hd : j.val%B+j.val/B*B=j.val := by simpa only [Nat.mul_comm] using Nat.mod_add_div j.val B
    have h := j.isLt
    omega⟩,by
    apply (mem_blockPrior p B _ j).mpr
    have hd : j.val%B+j.val/B*B=j.val := by simpa only [Nat.mul_comm] using Nat.mod_add_div j.val B
    change j.val/B*B≤j.val/B*B+a.val ∧ j.val/B*B+a.val<j.val
    constructor <;> omega⟩
  left_inv i := by
    apply Subtype.ext
    apply Fin.ext
    have h := (mem_blockPrior p B i.val j).mp i.property
    simp only
    omega
  right_inv a := by
    apply Fin.ext
    simp only
    omega

 theorem blockPriorEquiv_mod (p B : ℕ) (hB : 0<B) (j : Fin p) (a : Fin (j.val%B)) :
    ((blockPriorEquiv p B j).symm a).val.val%B=a.val := by
  change (j.val/B*B+a.val)%B=a.val
  rw [Nat.add_mod,Nat.mul_mod_left,Nat.zero_add,Nat.mod_mod,Nat.mod_eq_of_lt]
  exact a.isLt.trans (Nat.mod_lt _ hB)

 theorem bankPrefix_sum (c : ℕ → ℝ) (j : ℕ) : (∑i∈Finset.range j,(c i+2))=bankPrefix c j := by
  induction j with
  | zero => simp [bankPrefix]
  | succ j ih => rw [Finset.sum_range_succ,ih]; simp only [bankPrefix]; ring

 theorem bankTuple_card_bound {p B : ℕ} (hB : 0<B) (c : ℕ → ℝ) (K : Fin p → ℕ) (L : ℝ)
    (hK : ∀j,(K j:ℝ)≤Real.exp ((c (j.val%B)+2)*L)) (j : Fin p) :
    (Fintype.card (BankTuple K (blockPrior p B) j):ℝ)≤Real.exp (bankPrefix c (j.val%B)*L) := by
  have he : (Fintype.card (BankTuple K (blockPrior p B) j):ℝ)=
      ∏i : BankPrior (blockPrior p B) j,(K i.val:ℝ) := by
    simp only [BankTuple,Fintype.card_pi,Fintype.card_fin,Nat.cast_prod]
  rw [he]
  calc
    _ ≤ ∏i : BankPrior (blockPrior p B) j,Real.exp ((c (i.val.val%B)+2)*L) := by
      apply Finset.prod_le_prod₀
      · intro i _; positivity
      · intro i _; exact hK i.val
    _ = ∏a : Fin (j.val%B),Real.exp ((c a.val+2)*L) := by
      rw [← Equiv.prod_comp (blockPriorEquiv p B j).symm]
      apply Finset.prod_congr rfl
      intro a _
      rw [blockPriorEquiv_mod p B hB j a]
    _ = Real.exp (bankPrefix c (j.val%B)*L) := by
      rw [← Real.exp_sum,← Finset.sum_mul]
      congr 1
      have hs := Fin.sum_univ_eq_sum_range (fun i => c i+2) (j.val%B)
      rw [hs,bankPrefix_sum]

 theorem bankIndex_card_bound {p B : ℕ} (hB : 0<B) (c : ℕ → ℝ) (hc : ∀j,0≤c j)
    (K : Fin p → ℕ) {L : ℝ} (hL : 0≤L)
    (hK : ∀j,(K j:ℝ)≤Real.exp ((c (j.val%B)+2)*L)) :
    (Fintype.card (BankIndex K):ℝ)≤p*Real.exp (bankPrefix c B*L) := by
  simp only [BankIndex,Fintype.card_sigma,Fintype.card_fin,Nat.cast_sum]
  calc
    _ ≤ ∑_j : Fin p,Real.exp (bankPrefix c B*L) := by
      apply Finset.sum_le_sum
      intro j _
      exact (hK j).trans (Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_right
        (bankPrefix_cost_le c hc (Nat.mod_lt _ hB)) hL))
    _ = _ := by simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]

 theorem ceil_exp_bound {c L : ℝ} (hc : 0≤c) (hL : 1≤L) :
    (⌈Real.exp ((c+1)*L)⌉₊:ℝ)≤Real.exp ((c+2)*L) := by
  have hceil := Nat.ceil_lt_add_one (Real.exp_pos ((c+1)*L)).le
  have he0 : 1≤Real.exp ((c+1)*L) := Real.one_le_exp_iff.mpr (by positivity)
  have he1 : 2≤Real.exp L := by
    have h := Real.add_one_le_exp L
    linarith only [h,hL]
  have he : Real.exp ((c+2)*L)=Real.exp ((c+1)*L)*Real.exp L := by
    rw [← Real.exp_add]; congr 1; ring
  rw [he]
  nlinarith only [hceil,he0,he1]

end SK.Analytic

end
end

end OAI