import Mathlib
import OAI.Probability.BinarySweep.Trajectories.Trajectory

namespace OAI

noncomputable section
open scoped BigOperators Classical

namespace BinaryCoordinateSweeps

lemma weighted_entry_bound (n : ℕ) {p C a : ℝ} (hp : 0 ≤ p)
    (hbound : 0 < p → p ≤ Real.exp (C + a)) :
    p * Real.exp (-C / (n+1 : ℝ)) ≤
      Real.exp (a / (n+1 : ℝ)) * p ^ ((n : ℝ) / (n+1 : ℝ)) := by
  rcases hp.eq_or_lt with hp | hp
  · subst p
    simp only [zero_mul]
    positivity
  have hn : (0 : ℝ) < n+1 := by positivity
  have hl : Real.log p ≤ C + a := (Real.log_le_iff_le_exp hp).mpr (hbound hp)
  have he : Real.log p + -C / (n+1 : ℝ) ≤
      a / (n+1 : ℝ) + Real.log p * ((n : ℝ) / (n+1 : ℝ)) := by
    apply (mul_le_mul_iff_left₀ hn).mp
    field_simp
    nlinarith [hl]
  calc
    _ = Real.exp (Real.log p + -C / (n+1 : ℝ)) := by
      rw [Real.exp_add, Real.exp_log hp]
    _ ≤ Real.exp (a / (n+1 : ℝ) + Real.log p * ((n : ℝ) / (n+1 : ℝ))) :=
      Real.exp_le_exp.mpr he
    _ = _ := by rw [Real.exp_add, Real.rpow_def_of_pos hp]

theorem weighted_cycle_le_card {A : Type*} [Fintype A] (n : ℕ)
    (p C : Fin (n+1) → A → A → ℝ) (a : ℝ)
    (hp : ∀ i x y, 0 ≤ p i x y)
    (hsum : ∀ i y, ∑ x, p i x y = 1)
    (hbound : ∀ i x y, 0 < p i x y → p i x y ≤ Real.exp (C i x y + a)) :
    (∑ x : Fin (n+1) → A,
      ∏ i, p i (x i) (x (finRotate (n+1) i)) *
        Real.exp (-C i (x i) (x (finRotate (n+1) i)) / (n+1 : ℝ))) ≤
      Real.exp a * (Fintype.card A : ℝ) := by
  have hconstant : (∏ _i : Fin (n+1), Real.exp (a / (n+1 : ℝ))) = Real.exp a := by
    rw [Finset.prod_const, Finset.card_univ, Fintype.card_fin, ← Real.exp_nat_mul]
    congr 1
    push_cast
    field_simp
  calc
    _ ≤ ∑ x : Fin (n+1) → A,
      ∏ i, Real.exp (a / (n+1 : ℝ)) *
        (p i (x i) (x (finRotate (n+1) i))) ^ ((n : ℝ) / (n+1 : ℝ)) := by
      apply Finset.sum_le_sum
      intro x _
      apply Finset.prod_le_prod₀
      · intro i _; exact mul_nonneg (hp _ _ _) (Real.exp_pos _).le
      · intro i _; exact weighted_entry_bound n (hp _ _ _) (hbound _ _ _)
    _ = Real.exp a * (∑ x : Fin (n+1) → A,
      ∏ i, (p i (x i) (x (finRotate (n+1) i))) ^ ((n : ℝ) / (n+1 : ℝ))) := by
      simp_rw [Finset.prod_mul_distrib, hconstant]
      rw [Finset.mul_sum]
    _ ≤ _ := mul_le_mul_of_nonneg_left (Cyclic.sum_cycle_rpow_le_card n p hp hsum)
      (Real.exp_pos a).le

def placementEdgeCost {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    (z : ℝ) (reverse : Bool) {k : ℕ} (x y : Placement H k 0) : ℝ :=
  if reverse then placementTransitionCost H z y (placementIdentification H k x)
  else placementTransitionCost H z x (placementIdentification H k y)

lemma placementEdge_bound {b h r : ℕ} {bits : Fin b → ℕ}
    (H : PathFamily bits h) (hd : ∀ j, bits j ≤ 2*r) {z : ℝ}
    (hz : 0 ≤ z) (hzr : z ≤ linePerturbationRadius r)
    (reverse : Bool) {k : ℕ} (x y : Placement H k 0)
    (hp : 0 < placementEdge H z reverse x y) :
    placementEdge H z reverse x y ≤
      Real.exp (placementEdgeCost H z reverse x y +
        (-(k : ℝ) * Real.log (gridSize bits) - pathCost H + Real.log 4 * k * b)) := by
  have hsingle (x y : Placement H k 0) (hp : 0 < placementKernel H z x y) :
      placementKernel H z x y ≤ Real.exp (
        placementTransitionCost H z x (placementIdentification H k y) +
        (-(k : ℝ) * Real.log (gridSize bits) - pathCost H + Real.log 4 * k * b)) := by
    have hc := placement_probability_cost_of_pos H hd hz hzr x
      (placementIdentification H k y) hp
    have hs : (0 : ℝ) < gridSize bits := by exact_mod_cast gridSize_pos bits
    rw [Real.rpow_def_of_pos hs, ← Real.exp_add] at hc
    convert hc using 1 <;> congr 1
    ring
  cases reverse with
  | false => exact hsingle x y hp
  | true => exact hsingle y x hp

lemma linePerturbationRadius_lt_one (r : ℕ) : linePerturbationRadius r < 1 := by
  have hf : (1 : ℝ) ≤ ((2 ^ (2 * r)).factorial : ℝ) := by
    exact_mod_cast Nat.factorial_pos (2 ^ (2 * r))
  unfold linePerturbationRadius
  apply (div_lt_one (by positivity)).mpr
  linarith

theorem placement_weighted_cycle_bound {b h r : ℕ} {bits : Fin b → ℕ}
    (H : PathFamily bits h) (hd : ∀ j, bits j ≤ 2*r) {z : ℝ}
    (hz : 0 ≤ z) (hzr : z ≤ linePerturbationRadius r)
    (k n : ℕ) (reverse : Fin (n+1) → Bool) :
    (∑ x : Fin (n+1) → Placement H k 0,
      ∏ i, placementEdge H z (reverse i) (x i) (x (finRotate (n+1) i)) *
        Real.exp (-placementEdgeCost H z (reverse i) (x i) (x (finRotate (n+1) i)) /
          (n+1 : ℝ))) ≤ Real.exp (-pathCost H + Real.log 4 * k * b) := by
  have hz1 := hzr.trans_lt (linePerturbationRadius_lt_one r)
  have hc := weighted_cycle_le_card (A := Placement H k 0) n
    (fun i => placementEdge H z (reverse i))
    (fun i => placementEdgeCost H z (reverse i))
    (-(k : ℝ) * Real.log (gridSize bits) - pathCost H + Real.log 4 * k * b)
    (by
      intro i x y
      unfold placementEdge
      split_ifs <;> exact placementKernel_nonneg H hz hz1 _ _)
    (by
      intro i y
      unfold placementEdge
      cases reverse i with
      | false => exact placementKernel_colSum H hz hz1 y
      | true => exact placementKernel_rowSum H hz hz1 y)
    (by intro i x y hp; exact placementEdge_bound H hd hz hzr (reverse i) x y hp)
  rw [card_placement] at hc
  apply hc.trans
  have hcard : ((gridSize bits - h).descFactorial k : ℝ) ≤ (gridSize bits : ℝ) ^ k := by
    exact_mod_cast (Nat.descFactorial_le_pow (gridSize bits - h) k).trans
      (Nat.pow_le_pow_left (Nat.sub_le (gridSize bits) h) k)
  have hs : (0 : ℝ) < gridSize bits := by exact_mod_cast gridSize_pos bits
  calc
    _ ≤ Real.exp (-(k : ℝ) * Real.log (gridSize bits) - pathCost H + Real.log 4 * k * b) *
          (gridSize bits : ℝ) ^ k :=
      mul_le_mul_of_nonneg_left hcard (Real.exp_pos _).le
    _ = _ := by
      have he : (gridSize bits : ℝ) ^ k =
          Real.exp ((k : ℝ) * Real.log (gridSize bits)) := by
        rw [Real.exp_nat_mul, Real.exp_log hs]
      rw [he, ← Real.exp_add]
      congr 1
      ring

end BinaryCoordinateSweeps

end

end OAI