import OAI.Combinatorics.EditDistance.PrimePool
import OAI.Combinatorics.EditDistance.FamilyRecursion

namespace OAI

/-!
# Recursive parameter bounds and exponential lower scales
-/

namespace EditParameters
open EditFamily

def b (k : ℕ) := 100*k
def P (k : ℕ) := (b k)^2
def h (k : ℕ) := 10*k
noncomputable def eta (k : ℕ) : ℝ := 2 * (2 * (P k : ℝ)) ^ (2 * h k) / ((P k) ^ (b k / 2) : ℕ)

lemma prime_parameter_pos {k : ℕ} (hk : 0 < k) : 0 < P k := by
  unfold P b
  positivity

lemma eta_numerator_bound {k : ℕ} (hk : 0 < k) :
    2 * (2 * P k) ^ (2 * h k) * (h k)^k ≤ (P k) ^ (b k / 2) := by
  have hp : 4 ≤ P k := by dsimp [P,b]; nlinarith
  have hh : h k ≤ P k := by dsimp [h,P,b]; nlinarith
  have hpow : (2 * P k)^2 ≤ (P k)^3 := by nlinarith
  have he1 : 2*h k = 2*(10*k) := by rfl
  have he2 : b k / 2 = 50*k := by dsimp [b]; omega
  have htwo : 2 ≤ (P k)^k := le_trans (by omega : 2 ≤ P k)
    (Nat.le_self_pow (by omega) _)
  calc
    2 * (2*P k)^(2*h k) * (h k)^k ≤
        (P k)^k * ((P k)^3)^(10*k) * (P k)^k := by
          rw [he1,pow_mul]
          gcongr
    _ = (P k)^(32*k) := by rw [←pow_mul,←pow_add,←pow_add]; congr 1; omega
    _ ≤ (P k)^(b k / 2) := Nat.pow_le_pow_right (by omega) (by rw [he2]; omega)

lemma eta_le {k : ℕ} (hk : 0 < k) : eta k ≤ 1 / (h k : ℝ)^k := by
  have hp : (0 : ℝ) < ((P k)^(b k/2) : ℕ) := by
    exact_mod_cast pow_pos (prime_parameter_pos hk) _
  have hh : (0 : ℝ) < (h k : ℝ)^k := by dsimp [h]; positivity
  apply (div_le_div_iff₀ hp hh).mpr
  simpa only [one_mul,Nat.cast_mul,Nat.cast_pow,Nat.cast_ofNat] using
    (show (2 : ℝ) * (2*(P k : ℝ))^(2*h k) * (h k : ℝ)^k ≤ ((P k)^(b k/2) : ℕ) by
      exact_mod_cast eta_numerator_bound hk)

lemma budget_bound {k : ℕ} (hk : 0 < k) (s : ℕ) :
    familyBudget (b k) (P k) (h k) s ≤ 2/(h k : ℝ)^s + 2*eta k := by
  have hp : (0 : ℝ) < h k := by dsimp [h]; positivity
  have htwo : (2 : ℝ) ≤ h k := by exact_mod_cast (show 2 ≤ h k by dsimp [h]; omega)
  have he : 0 ≤ eta k := by dsimp [eta]; positivity
  induction s with
  | zero => simp only [familyBudget,pow_zero,div_one]; linarith
  | succ s ih =>
    change eta k + familyBudget (b k) (P k) (h k) s / h k ≤ _
    calc
      _ ≤ eta k + (2/(h k : ℝ)^s+2*eta k)/(h k) := by gcongr
      _ = 2/(h k : ℝ)^(s+1) + (eta k + 2*eta k/(h k)) := by
        rw [pow_succ]; field_simp; ring
      _ ≤ 2/(h k : ℝ)^(s+1) + 2*eta k := by
        have ht : 2*eta k/(h k) ≤ eta k := (div_le_iff₀ hp).mpr (by nlinarith)
        linarith

theorem budget_small {k : ℕ} (hk : 0 < k) :
    familyBudget (b k) (P k) (h k) k ≤ 4/(h k : ℝ)^k := by
  have h1 := budget_bound hk k
  have h2 := eta_le hk
  simp only [div_eq_mul_inv,one_mul] at *
  linarith

def codeBits (k : ℕ) := Nat.clog 2 (familyAlphabet (b k) (P k) k)
def codeWidth (k : ℕ) := 2*codeBits k+3
def encodedLength (k : ℕ) := codeWidth k * familyLength (b k) (P k) k

lemma alphabet_power_bound {k : ℕ} (hk : 0 < k) :
    familyAlphabet (b k) (P k) k ≤ 2^(30*k^2) := by
  have hb : 0 < b k := by dsimp [b]; omega
  have hp : 0 < P k := prime_parameter_pos hk
  have hkb : k ≤ 2^k := Nat.lt_two_pow_self.le
  have hbpow : 2*b k ≤ 2^(k+8) := by
    simp only [pow_add]
    norm_num only [show 2^8=256 by norm_num]
    dsimp [b]
    nlinarith
  have hppow : 2*P k+1 ≤ 2^(2*k+16) := by
    calc
      2*P k+1 ≤ (2*b k)^2 := by dsimp [P]; nlinarith
      _ ≤ (2^(k+8))^2 := Nat.pow_le_pow_left hbpow 2
      _ = _ := by rw [←pow_mul]; congr 1; ring
  calc
    familyAlphabet (b k) (P k) k ≤ (2*P k+1)*(2*b k)^k := familyAlphabet_le hb hp k
    _ ≤ 2^(2*k+16)*(2^(k+8))^k := Nat.mul_le_mul hppow (Nat.pow_le_pow_left hbpow k)
    _ = 2^(k^2+10*k+16) := by rw [←pow_mul,←pow_add]; congr 1; ring
    _ ≤ 2^(30*k^2) := Nat.pow_le_pow_right (by omega) (by nlinarith)

lemma bits_poly {k : ℕ} (hk : 0 < k) : codeBits k ≤ 30*k^2 :=
  (Nat.clog_le_iff_le_pow (by norm_num)).mpr (alphabet_power_bound hk)

lemma width_poly {k : ℕ} (hk : 0 < k) : codeWidth k ≤ 63*k^2 := by
  have ht := bits_poly hk
  dsimp [codeWidth]
  nlinarith

lemma width_pos (k : ℕ) : 0 < codeWidth k := by dsimp [codeWidth]; omega
lemma encodedLength_pos {k : ℕ} (hk : 0 < k) : 0 < encodedLength k :=
  Nat.mul_pos (width_pos k) (familyLength_pos (by dsimp [b]; omega) (prime_parameter_pos hk) k)

lemma length_power_bound (k : ℕ) : familyLength (b k) (P k) k ≤
    (4*(b k)^(100*k+1))^k := by
  have he : b k / 2 = 50*k := by dsimp [b]; omega
  unfold familyLength
  apply Nat.pow_le_pow_left
  calc
    2*(2*b k-1)*(P k)^(b k/2) ≤ 4*b k*(P k)^(b k/2) :=
      Nat.mul_le_mul_right _ (by have := Nat.sub_le (2*b k) 1; omega)
    _ = 4*(b k)^(100*k+1) := by
      dsimp [P]
      rw [he,←pow_mul,pow_succ]
      have he' : 2*(50*k)=100*k := by omega
      rw [he']
      ring

theorem log_length_bound {k : ℕ} (hk : 2 ≤ k) :
    Real.log (encodedLength k : ℝ) ≤ 1000*(k : ℝ)^2*Real.log (k : ℝ) := by
  have hkpos : 0 < k := by omega
  have kr : (2 : ℝ) ≤ k := by exact_mod_cast hk
  have kp : (0 : ℝ) < k := by positivity
  have bp : (0 : ℝ) < b k := by dsimp [b]; positivity
  have wp : (0 : ℝ) < codeWidth k := by exact_mod_cast width_pos k
  have np : (0 : ℝ) < familyLength (b k) (P k) k := by
    exact_mod_cast familyLength_pos (by dsimp [b]; omega) (prime_parameter_pos hkpos) k
  have lk : 0 ≤ Real.log (k : ℝ) := Real.log_nonneg (by linarith)
  have l2 : Real.log (2 : ℝ) ≤ Real.log (k : ℝ) := Real.log_le_log (by norm_num) kr
  have l63 : Real.log (63 : ℝ) ≤ 6*Real.log (2 : ℝ) := by
    have ht := Real.log_le_log (by norm_num : (0 : ℝ)<63) (by norm_num : (63 : ℝ) ≤ 2^6)
    simpa only [Real.log_pow,Nat.cast_ofNat] using ht
  have l100 : Real.log (100 : ℝ) ≤ 7*Real.log (2 : ℝ) := by
    have ht := Real.log_le_log (by norm_num : (0 : ℝ)<100) (by norm_num : (100 : ℝ) ≤ 2^7)
    simpa only [Real.log_pow,Nat.cast_ofNat] using ht
  have l4 : Real.log (4 : ℝ) = 2*Real.log (2 : ℝ) := by
    rw [show (4 : ℝ)=2^2 by norm_num,Real.log_pow]; norm_num
  have lb : Real.log (b k : ℝ) ≤ 8*Real.log (k : ℝ) := by
    simp only [b,Nat.cast_mul,Nat.cast_ofNat,Real.log_mul (by norm_num : (100 : ℝ) ≠ 0) kp.ne']
    linarith
  have lw : Real.log (codeWidth k : ℝ) ≤ 8*Real.log (k : ℝ) := by
    have hw : (codeWidth k : ℝ) ≤ 63*(k : ℝ)^2 := by exact_mod_cast width_poly hkpos
    have hl := Real.log_le_log wp hw
    rw [Real.log_mul (by norm_num) (by positivity),Real.log_pow] at hl
    norm_num only [Nat.cast_ofNat] at hl
    linarith
  have ln : Real.log (familyLength (b k) (P k) k : ℝ) ≤
      (k : ℝ)*(Real.log (4 : ℝ)+(100*(k : ℝ)+1)*Real.log (b k : ℝ)) := by
    have hn : (familyLength (b k) (P k) k : ℝ) ≤
        (4*(b k : ℝ)^(100*k+1))^k := by exact_mod_cast length_power_bound k
    have hl := Real.log_le_log np hn
    rw [Real.log_pow,Real.log_mul (by norm_num) (by positivity),Real.log_pow] at hl
    push_cast at hl
    exact hl
  have he : Real.log (encodedLength k : ℝ) =
      Real.log (codeWidth k : ℝ)+Real.log (familyLength (b k) (P k) k : ℝ) := by
    simp only [encodedLength,Nat.cast_mul,Real.log_mul wp.ne' np.ne']
  rw [he]
  calc
    _ ≤ 8*Real.log (k : ℝ)+(k : ℝ)*(2*Real.log (k : ℝ)+
        (100*(k : ℝ)+1)*(8*Real.log (k : ℝ))) := by
      apply add_le_add lw
      apply ln.trans
      gcongr
      linarith
    _ = (800*(k : ℝ)^2+10*(k : ℝ)+8)*Real.log (k : ℝ) := by ring
    _ ≤ 1000*(k : ℝ)^2*Real.log (k : ℝ) := by
      gcongr
      nlinarith

noncomputable def lowerRatio (k : ℕ) : ℝ := ((h k : ℝ)/24)^k/(16*(codeWidth k : ℝ))

lemma log_width_le {k : ℕ} (hk : 0 < k) :
    Real.log (codeWidth k : ℝ) ≤ Real.log (63 : ℝ)+2*Real.log (k : ℝ) := by
  have hw : (codeWidth k : ℝ) ≤ 63*(k : ℝ)^2 := by exact_mod_cast width_poly hk
  have wp : (0 : ℝ) < codeWidth k := by exact_mod_cast width_pos k
  have kp : (0 : ℝ) < k := by exact_mod_cast hk
  have hh := Real.log_le_log wp hw
  rw [Real.log_mul (by norm_num) (by positivity),Real.log_pow] at hh
  norm_num only [Nat.cast_ofNat] at hh
  exact hh

theorem ratio_exponential {k : ℕ} (hk : 24^4 ≤ k) :
    Real.exp ((1/2 : ℝ)*(k : ℝ)*Real.log (k : ℝ)) ≤ lowerRatio k := by
  have hk0 : 0 < k := by norm_num at hk; omega
  have kp : (0 : ℝ) < k := by exact_mod_cast hk0
  have k12 : (12 : ℝ) ≤ k := by exact_mod_cast (show 12 ≤ k by norm_num at hk; omega)
  have k1008 : (1008 : ℝ) ≤ k := by exact_mod_cast (show 1008 ≤ k by norm_num at hk; omega)
  have hn : (0 : ℝ) < h k := by dsimp [h]; positivity
  have wp : (0 : ℝ) < codeWidth k := by exact_mod_cast width_pos k
  have rp : 0 < lowerRatio k := by dsimp [lowerRatio]; positivity
  apply (Real.le_log_iff_exp_le rp).mp
  have lkp : 0 ≤ Real.log (k : ℝ) := Real.log_nonneg (by linarith)
  have l24 : 4*Real.log (24 : ℝ) ≤ Real.log (k : ℝ) := by
    have ht := Real.log_le_log (by norm_num : (0 : ℝ)<24^4)
      (show (24 : ℝ)^4 ≤ k by exact_mod_cast hk)
    simpa only [Real.log_pow,Nat.cast_ofNat] using ht
  have lh : Real.log (k : ℝ) ≤ Real.log (h k : ℝ) := by
    apply Real.log_le_log kp
    dsimp [h]; push_cast; nlinarith
  have lw := log_width_le hk0
  have lconst : Real.log (16 : ℝ)+Real.log (63 : ℝ) ≤ Real.log (k : ℝ) := by
    rw [←Real.log_mul (by norm_num) (by norm_num)]
    norm_num only [show (16 : ℝ)*63=1008 by norm_num]
    exact Real.log_le_log (by norm_num) k1008
  have logeq : Real.log (lowerRatio k) =
      (k : ℝ)*(Real.log (h k : ℝ)-Real.log (24 : ℝ))-
        (Real.log (16 : ℝ)+Real.log (codeWidth k : ℝ)) := by
    dsimp [lowerRatio]
    rw [Real.log_div (by positivity) (by positivity),Real.log_pow,
      Real.log_div hn.ne' (by norm_num),Real.log_mul (by norm_num) wp.ne']
  rw [logeq]
  have h1 := mul_le_mul_of_nonneg_left lh kp.le
  have h2 := mul_le_mul_of_nonneg_left l24 kp.le
  have h3 : 12*Real.log (k : ℝ) ≤ (k : ℝ)*Real.log (k : ℝ) :=
    mul_le_mul_of_nonneg_right k12 lkp
  nlinarith

end EditParameters

end OAI