import Mathlib
import OAI.Probability.BinarySweep.Conditional.Placement

namespace OAI

noncomputable section
open scoped BigOperators Classical

namespace BinaryCoordinateSweeps
attribute [local instance] Classical.propDecidable

structure PathExtension {b h h' : ℕ} {bits : Fin b → ℕ}
    (H : PathFamily bits h) (H' : PathFamily bits h') where
  labels : Fin h ↪ Fin h'
  position_eq : ∀ t i, H'.position t (labels i) = H.position t i

namespace PathExtension
variable {b h h' : ℕ} {bits : Fin b → ℕ}
  {H : PathFamily bits h} {H' : PathFamily bits h'}

def lineEmbedding (E : PathExtension H H') (j : Fin b) (y : GridOutside bits j) :
    LinePaths H j y ↪ LinePaths H' j y where
  toFun i := ⟨E.labels i.val, by
    change (fun a : {a : Fin b // a ≠ j} => H'.position j.castSucc (E.labels i.val) a) = y
    rw [E.position_eq]
    exact i.property⟩
  inj' i k hik := Subtype.ext (E.labels.injective (congrArg Subtype.val hik))

lemma lineInput_eq (E : PathExtension H H') (j : Fin b) (y : GridOutside bits j)
    (i : LinePaths H j y) :
    lineInput H' j y (E.lineEmbedding j y i) = lineInput H j y i := by
  change H'.position j.castSucc (E.labels i.val) j = H.position j.castSucc i.val j
  rw [E.position_eq]

lemma lineOutput_eq (E : PathExtension H H') (j : Fin b) (y : GridOutside bits j)
    (i : LinePaths H j y) :
    lineOutput H' j y (E.lineEmbedding j y i) = lineOutput H j y i := by
  change H'.position j.succ (E.labels i.val) j = H.position j.succ i.val j
  rw [E.position_eq]

lemma pathEvent_mono (E : PathExtension H H') {g : GridChoices bits}
    (hg : pathEvent H' g) : pathEvent H g := by
  intro j i
  simpa only [E.position_eq] using hg j (E.labels i)

lemma card_le (E : PathExtension H H') : h ≤ h' := by
  simpa only [Fintype.card_fin] using Fintype.card_le_of_injective E.labels E.labels.injective

end PathExtension

lemma localPathWeight_pos_comparison {b h r : ℕ} {bits : Fin b → ℕ}
    (H : PathFamily bits h) (hd : ∀ j, bits j ≤ 2*r) {z : ℝ}
    (hz : 0 ≤ z) (hzr : z ≤ linePerturbationRadius r)
    (j : Fin b) (y : GridOutside bits j) : 0 < localPathWeight H z j y := by
  unfold localPathWeight
  have hw := @assignmentWeight_comparison (Slot (bits j)) (LinePaths H j y) _ _
    (lineLaw (bits j) z) ?_ ?_ (lineInput H j y) (lineOutput H j y)
  · have hm : 0 < (Nat.descFactorial (Fintype.card (Slot (bits j)))
        (Fintype.card (LinePaths H j y)) : ℝ) := by
      exact_mod_cast Nat.descFactorial_pos.mpr
        (Fintype.card_le_of_injective (lineInput H j y) (lineInput H j y).injective)
    exact lt_of_lt_of_le (by positivity) hw.1
  · intro σ
    simpa only [uniformLaw, Fintype.card_perm] using
      (lineLaw_comparison r (bits j) (hd j) hz hzr σ).1
  · intro σ
    simpa only [uniformLaw, Fintype.card_perm] using
      (lineLaw_comparison r (bits j) (hd j) hz hzr σ).2

lemma lineExtension_log_bound {b h h' r : ℕ} {bits : Fin b → ℕ}
    {H : PathFamily bits h} {H' : PathFamily bits h'} (E : PathExtension H H')
    (hd : ∀ j, bits j ≤ 2*r) {z : ℝ}
    (hz : 0 ≤ z) (hzr : z ≤ linePerturbationRadius r)
    (j : Fin b) (y : GridOutside bits j) :
    Real.log (localPathWeight H' z j y / localPathWeight H z j y) ≤
      fallingCost (2^bits j) (lineHoles H' j y) - fallingCost (2^bits j) (lineHoles H j y) -
      ((lineHoles H' j y : ℝ) - lineHoles H j y) * Real.log (2^bits j : ℕ) +
      Real.log 4 * ((lineHoles H' j y : ℝ) - lineHoles H j y) := by
  have he := @assignmentWeight_log_ratio_le (Slot (bits j)) (LinePaths H j y)
    (LinePaths H' j y) _ _ _ Fintype.card_pos (lineLaw (bits j) z)
    ?_ ?_ (lineInput H j y) (lineOutput H j y) (lineInput H' j y) (lineOutput H' j y)
      (E.lineEmbedding j y) (E.lineInput_eq j y) (E.lineOutput_eq j y)
  · simpa only [localPathWeight, lineHoles, Slot, Fintype.card_fun, Fintype.card_fin,
      Fintype.card_bool] using he
  · intro σ
    simpa only [uniformLaw, Fintype.card_perm] using
      (lineLaw_comparison r (bits j) (hd j) hz hzr σ).1
  · intro σ
    simpa only [uniformLaw, Fintype.card_perm] using
      (lineLaw_comparison r (bits j) (hd j) hz hzr σ).2

lemma log_gridSize {b : ℕ} (bits : Fin b → ℕ) :
    Real.log (gridSize bits : ℝ) = ∑ j, Real.log (2^bits j : ℕ) := by
  unfold gridSize
  rw [Nat.cast_prod, Real.log_prod]
  intro j _
  positivity

lemma sum_lineHoles_sub {b h h' : ℕ} {bits : Fin b → ℕ}
    (H : PathFamily bits h) (H' : PathFamily bits h') (j : Fin b) :
    ∑ y : GridOutside bits j, ((lineHoles H' j y : ℝ) - lineHoles H j y) = (h' : ℝ) - h := by
  rw [Finset.sum_sub_distrib, ← Nat.cast_sum, ← Nat.cast_sum, sum_lineHoles, sum_lineHoles]

lemma pathCost_eq_sum {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h) :
    pathCost H = ∑ j, ∑ y, fallingCost (2^bits j) (lineHoles H j y) := rfl

theorem pathExtension_log_ratio {b h h' r : ℕ} {bits : Fin b → ℕ}
    {H : PathFamily bits h} {H' : PathFamily bits h'} (E : PathExtension H H')
    (hd : ∀ j, bits j ≤ 2*r) {z : ℝ}
    (hz : 0 ≤ z) (hzr : z ≤ linePerturbationRadius r) :
    Real.log (conditionalNormalizer H' z / conditionalNormalizer H z) ≤
      pathCost H' - pathCost H - ((h' : ℝ) - h) * Real.log (gridSize bits) +
        Real.log 4 * ((h' : ℝ) - h) * b := by
  have hposH := localPathWeight_pos_comparison H hd hz hzr
  have hposH' := localPathWeight_pos_comparison H' hd hz hzr
  rw [conditionalNormalizer_eq_prod, conditionalNormalizer_eq_prod]
  rw [← Finset.prod_div_distrib]
  simp_rw [← Finset.prod_div_distrib]
  rw [Real.log_prod (fun j _ => Finset.prod_ne_zero_iff.mpr (fun y _ =>
    (div_pos (hposH' j y) (hposH j y)).ne'))]
  simp_rw [Real.log_prod (fun y _ => (div_pos (hposH' _ y) (hposH _ y)).ne')]
  calc
    _ ≤ ∑ j, ∑ y,
        (fallingCost (2^bits j) (lineHoles H' j y) - fallingCost (2^bits j) (lineHoles H j y) -
        ((lineHoles H' j y : ℝ) - lineHoles H j y) * Real.log (2^bits j : ℕ) +
        Real.log 4 * ((lineHoles H' j y : ℝ) - lineHoles H j y)) := by
      apply Finset.sum_le_sum
      intro j _
      exact Finset.sum_le_sum (fun y _ => lineExtension_log_bound E hd hz hzr j y)
    _ = _ := by
      simp_rw [Finset.sum_add_distrib, Finset.sum_sub_distrib,
        ← Finset.sum_mul, ← Finset.mul_sum]
      simp_rw [sum_lineHoles_sub]
      rw [pathCost_eq_sum, pathCost_eq_sum, log_gridSize]
      simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
      rw [← Finset.mul_sum]
      ring

def conditionalEventWeight {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    (z : ℝ) (P : GridChoices bits → Prop) : ℝ :=
  ∑ g : ConditionalChoices H, if P g.val then conditionalChoiceWeight H z g else 0

lemma pathExtension_event_ratio {b h h' : ℕ} {bits : Fin b → ℕ}
    {H : PathFamily bits h} {H' : PathFamily bits h'} (E : PathExtension H H') (z : ℝ) :
    conditionalEventWeight H z (pathEvent H') =
      conditionalNormalizer H' z / conditionalNormalizer H z := by
  unfold conditionalEventWeight conditionalChoiceWeight
  have hdiv (g : ConditionalChoices H) :
      (if pathEvent H' g.val then gridWeight bits z g.val / conditionalNormalizer H z else 0) =
      (if pathEvent H' g.val then gridWeight bits z g.val else 0) / conditionalNormalizer H z := by
    split_ifs <;> simp only [zero_div]
  simp_rw [hdiv]
  rw [← Finset.sum_div]
  congr 1
  rw [← Finset.sum_subtype (Finset.univ.filter (pathEvent H)) (by simp)
    (fun g => if pathEvent H' g then gridWeight bits z g else 0)]
  rw [Finset.sum_filter]
  unfold conditionalNormalizer
  apply Finset.sum_congr rfl
  intro g _
  by_cases hg : pathEvent H' g
  · simp only [hg, E.pathEvent_mono hg, ite_true]
  · simp only [hg, ite_false, ite_self]

lemma gridSize_pos {b : ℕ} (bits : Fin b → ℕ) : 0 < gridSize bits := by
  unfold gridSize
  exact Finset.prod_pos (fun j _ => Nat.pow_pos (by norm_num))

theorem pathExtension_probability_bound {b h k r : ℕ} {bits : Fin b → ℕ}
    {H : PathFamily bits h} {H' : PathFamily bits (h+k)} (E : PathExtension H H')
    (hd : ∀ j, bits j ≤ 2*r) {z : ℝ}
    (hz : 0 ≤ z) (hzr : z ≤ linePerturbationRadius r) :
    conditionalEventWeight H z (pathEvent H') ≤
      (gridSize bits : ℝ) ^ (-(k : ℝ)) *
        Real.exp (pathCost H' - pathCost H + Real.log 4 * k * b) := by
  rw [pathExtension_event_ratio E]
  have hp : 0 < conditionalNormalizer H' z / conditionalNormalizer H z := by
    rw [conditionalNormalizer_eq_prod, conditionalNormalizer_eq_prod]
    apply div_pos <;> apply Finset.prod_pos <;> intro j _ <;>
      apply Finset.prod_pos <;> intro y _
    · exact localPathWeight_pos_comparison H' hd hz hzr j y
    · exact localPathWeight_pos_comparison H hd hz hzr j y
  have hs : (0 : ℝ) < gridSize bits := by exact_mod_cast gridSize_pos bits
  have he := pathExtension_log_ratio E hd hz hzr
  simp only [Nat.cast_add, add_sub_cancel_left] at he
  calc
    _ ≤ Real.exp (pathCost H' - pathCost H - (k : ℝ) * Real.log (gridSize bits) +
        Real.log 4 * k * b) := (Real.log_le_iff_le_exp hp).mp he
    _ = _ := by
      rw [Real.rpow_def_of_pos hs, ← Real.exp_add]
      congr 1
      ring

end BinaryCoordinateSweeps

end

end OAI